8.91 MB
a/Assembly-CSharp-64.zip vs.
b/Assembly-CSharp-813.zip
2.73 MB
zipinfo -v {}
Differences in extra fields detected; using output from zipinfo -v
    
Offset 1, 22 lines modifiedOffset 1, 22 lines modified
1 There·is·no·zipfile·comment.1 There·is·no·zipfile·comment.
  
2 End-of-central-directory·record:2 End-of-central-directory·record:
3 -------------------------------3 -------------------------------
  
4 ··Zip·archive·file·size:···················1341229·(000000000014772Dh)4 ··Zip·archive·file·size:···················1422880·(000000000015B620h)
5 ··Actual·end-cent-dir·record·offset:·······1341207·(0000000000147717h)5 ··Actual·end-cent-dir·record·offset:·······1422858·(000000000015B60Ah)
6 ··Expected·end-cent-dir·record·offset:·····1341207·(0000000000147717h)6 ··Expected·end-cent-dir·record·offset:·····1422858·(000000000015B60Ah)
7 ··(based·on·the·length·of·the·central·directory·and·its·expected·offset)7 ··(based·on·the·length·of·the·central·directory·and·its·expected·offset)
  
8 ··This·zipfile·constitutes·the·sole·disk·of·a·single-part·archive;·its8 ··This·zipfile·constitutes·the·sole·disk·of·a·single-part·archive;·its
9 ··central·directory·contains·1338·entries.9 ··central·directory·contains·1408·entries.
10 ··The·central·directory·is·163038·(0000000000027CDEh)·bytes·long,10 ··The·central·directory·is·172393·(000000000002A169h)·bytes·long,
11 ··and·its·(expected)·offset·in·bytes·from·the·beginning·of·the·zipfile11 ··and·its·(expected)·offset·in·bytes·from·the·beginning·of·the·zipfile
12 ··is·1178169·(000000000011FA39h).12 ··is·1250465·(00000000001314A1h).
  
  
13 Central·directory·entry·#1:13 Central·directory·entry·#1:
14 ---------------------------14 ---------------------------
  
15 ··Assembly-CSharp/15 ··Assembly-CSharp/
  
Offset 25, 29 lines modifiedOffset 25, 29 lines modified
25 ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT25 ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT
26 ··version·of·encoding·software:···················3.126 ··version·of·encoding·software:···················3.1
27 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT27 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT
28 ··minimum·software·version·required·to·extract:···1.028 ··minimum·software·version·required·to·extract:···1.0
29 ··compression·method:·····························none·(stored)29 ··compression·method:·····························none·(stored)
30 ··file·security·status:···························not·encrypted30 ··file·security·status:···························not·encrypted
31 ··extended·local·header:··························no31 ··extended·local·header:··························no
32 ··file·last·modified·on·(DOS·date/time):··········2024·Sep·5·21:23:4432 ··file·last·modified·on·(DOS·date/time):··········2024·Sep·4·22:20:28
33 ··32-bit·CRC·value·(hex):·························0000000033 ··32-bit·CRC·value·(hex):·························00000000
34 ··compressed·size:································0·bytes34 ··compressed·size:································0·bytes
35 ··uncompressed·size:······························0·bytes35 ··uncompressed·size:······························0·bytes
36 ··length·of·filename:·····························16·characters36 ··length·of·filename:·····························16·characters
37 ··length·of·extra·field:··························36·bytes37 ··length·of·extra·field:··························36·bytes
38 ··length·of·file·comment:·························0·characters38 ··length·of·file·comment:·························0·characters
39 ··disk·number·on·which·file·begins:···············disk·139 ··disk·number·on·which·file·begins:···············disk·1
40 ··apparent·file·type:·····························binary40 ··apparent·file·type:·····························binary
41 ··non-MSDOS·external·file·attributes:·············000000·hex41 ··non-MSDOS·external·file·attributes:·············000000·hex
42 ··MS-DOS·file·attributes·(10·hex):················dir·42 ··MS-DOS·file·attributes·(10·hex):················dir·
  
43 ··The·central-directory·extra·field·contains:43 ··The·central-directory·extra·field·contains:
44 ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first44 ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first
45 ····20·are:···00·00·00·00·01·00·18·00·7c·db·3f·08·f3·ff·da·01·8f·29·40·08.45 ····20·are:···00·00·00·00·01·00·18·00·ac·1d·e0·ca·31·ff·da·01·e1·f1·c9·ce.
  
46 ··There·is·no·file·comment.46 ··There·is·no·file·comment.
  
47 Central·directory·entry·#2:47 Central·directory·entry·#2:
48 ---------------------------48 ---------------------------
  
49 ··There·are·an·extra·-36·bytes·preceding·this·file.49 ··There·are·an·extra·-36·bytes·preceding·this·file.
Offset 60, 46726 lines modifiedOffset 60, 49175 lines modified
60 ··version·of·encoding·software:···················3.160 ··version·of·encoding·software:···················3.1
61 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT61 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT
62 ··minimum·software·version·required·to·extract:···2.062 ··minimum·software·version·required·to·extract:···2.0
63 ··compression·method:·····························deflated63 ··compression·method:·····························deflated
64 ··compression·sub-type·(deflation):···············normal64 ··compression·sub-type·(deflation):···············normal
65 ··file·security·status:···························not·encrypted65 ··file·security·status:···························not·encrypted
66 ··extended·local·header:··························no66 ··extended·local·header:··························no
67 ··file·last·modified·on·(DOS·date/time):··········2024·Sep·5·21:23:3867 ··file·last·modified·on·(DOS·date/time):··········2024·Sep·4·22:20:20
68 ··32-bit·CRC·value·(hex):·························6540c0fc68 ··32-bit·CRC·value·(hex):·························5b29d606
69 ··compressed·size:································592·bytes69 ··compressed·size:································612·bytes
70 ··uncompressed·size:······························1318·bytes70 ··uncompressed·size:······························1480·bytes
71 ··length·of·filename:·····························32·characters71 ··length·of·filename:·····························32·characters
72 ··length·of·extra·field:··························36·bytes72 ··length·of·extra·field:··························36·bytes
73 ··length·of·file·comment:·························0·characters73 ··length·of·file·comment:·························0·characters
74 ··disk·number·on·which·file·begins:···············disk·174 ··disk·number·on·which·file·begins:···············disk·1
75 ··apparent·file·type:·····························binary75 ··apparent·file·type:·····························binary
76 ··non-MSDOS·external·file·attributes:·············000000·hex76 ··non-MSDOS·external·file·attributes:·············000000·hex
77 ··MS-DOS·file·attributes·(20·hex):················arc·77 ··MS-DOS·file·attributes·(20·hex):················arc·
  
78 ··The·central-directory·extra·field·contains:78 ··The·central-directory·extra·field·contains:
79 ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first79 ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first
80 ····20·are:···00·00·00·00·01·00·18·00·28·e6·05·05·f3·ff·da·01·28·e6·05·05.80 ····20·are:···00·00·00·00·01·00·18·00·9e·cc·85·c6·31·ff·da·01·9e·cc·85·c6.
  
81 ··There·is·no·file·comment.81 ··There·is·no·file·comment.
  
82 Central·directory·entry·#3:82 Central·directory·entry·#3:
83 ---------------------------83 ---------------------------
  
84 ··There·are·an·extra·-36·bytes·preceding·this·file.84 ··There·are·an·extra·-36·bytes·preceding·this·file.
  
85 ··Assembly-CSharp/AbilityButtonSettings.cs85 ··Assembly-CSharp/AbilityButtonSettings.cs
  
86 ··offset·of·local·header·from·start·of·archive:···70086 ··offset·of·local·header·from·start·of·archive:···720
87 ··················································(00000000000002BCh)·bytes87 ··················································(00000000000002D0h)·bytes
88 ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT88 ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT
89 ··version·of·encoding·software:···················3.189 ··version·of·encoding·software:···················3.1
90 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT90 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT
91 ··minimum·software·version·required·to·extract:···2.091 ··minimum·software·version·required·to·extract:···2.0
92 ··compression·method:·····························deflated92 ··compression·method:·····························deflated
93 ··compression·sub-type·(deflation):···············normal93 ··compression·sub-type·(deflation):···············normal
94 ··file·security·status:···························not·encrypted94 ··file·security·status:···························not·encrypted
95 ··extended·local·header:··························no95 ··extended·local·header:··························no
96 ··file·last·modified·on·(DOS·date/time):··········2024·Sep·5·21:23:3896 ··file·last·modified·on·(DOS·date/time):··········2024·Sep·4·22:20:20
97 ··32-bit·CRC·value·(hex):·························6653cc5497 ··32-bit·CRC·value·(hex):·························4342ee09
98 ··compressed·size:································155·bytes98 ··compressed·size:································162·bytes
99 ··uncompressed·size:······························206·bytes99 ··uncompressed·size:······························237·bytes
100 ··length·of·filename:·····························40·characters100 ··length·of·filename:·····························40·characters
101 ··length·of·extra·field:··························36·bytes101 ··length·of·extra·field:··························36·bytes
102 ··length·of·file·comment:·························0·characters102 ··length·of·file·comment:·························0·characters
103 ··disk·number·on·which·file·begins:···············disk·1103 ··disk·number·on·which·file·begins:···············disk·1
104 ··apparent·file·type:·····························binary104 ··apparent·file·type:·····························binary
105 ··non-MSDOS·external·file·attributes:·············000000·hex105 ··non-MSDOS·external·file·attributes:·············000000·hex
106 ··MS-DOS·file·attributes·(20·hex):················arc·106 ··MS-DOS·file·attributes·(20·hex):················arc·
  
107 ··The·central-directory·extra·field·contains:107 ··The·central-directory·extra·field·contains:
108 ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first108 ··-·A·subfield·with·ID·0x000a·(PKWARE·Win32)·and·32·data·bytes.··The·first
109 ····20·are:···00·00·00·00·01·00·18·00·9b·5b·06·05·f3·ff·da·01·9b·5b·06·05.109 ····20·are:···00·00·00·00·01·00·18·00·c9·41·86·c6·31·ff·da·01·c9·41·86·c6.
  
110 ··There·is·no·file·comment.110 ··There·is·no·file·comment.
  
111 Central·directory·entry·#4:111 Central·directory·entry·#4:
112 ---------------------------112 ---------------------------
  
113 ··There·are·an·extra·-36·bytes·preceding·this·file.113 ··There·are·an·extra·-36·bytes·preceding·this·file.
  
114 ··Assembly-CSharp/AbstractChatInputField.cs114 ··Assembly-CSharp/AbstractChatInputField.cs
  
115 ··offset·of·local·header·from·start·of·archive:···925115 ··offset·of·local·header·from·start·of·archive:···952
116 ··················································(000000000000039Dh)·bytes116 ··················································(00000000000003B8h)·bytes
117 ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT117 ··file·system·or·operating·system·of·origin:······MS-DOS,·OS/2·or·NT·FAT
118 ··version·of·encoding·software:···················3.1118 ··version·of·encoding·software:···················3.1
119 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT119 ··minimum·file·system·compatibility·required:·····MS-DOS,·OS/2·or·NT·FAT
120 ··minimum·software·version·required·to·extract:···2.0120 ··minimum·software·version·required·to·extract:···2.0
121 ··compression·method:·····························deflated121 ··compression·method:·····························deflated
Max diff block lines reached; 2850150/2857576 bytes (99.74%) of diff not shown.
17.3 KB
zipnote {}
    
Offset 51, 15 lines modifiedOffset 51, 15 lines modified
  
51 Filename:·Assembly-CSharp/AdjustSteeringGame.cs51 Filename:·Assembly-CSharp/AdjustSteeringGame.cs
52 Comment:·52 Comment:·
  
53 Filename:·Assembly-CSharp/AdminButton.cs53 Filename:·Assembly-CSharp/AdminButton.cs
54 Comment:·54 Comment:·
  
55 Filename:·Assembly-CSharp/AdvancedRoleSettingsButton.cs55 Filename:·Assembly-CSharp/AdvancedRoleViewPanel.cs
56 Comment:·56 Comment:·
  
57 Filename:·Assembly-CSharp/AgeGateScreen.cs57 Filename:·Assembly-CSharp/AgeGateScreen.cs
58 Comment:·58 Comment:·
  
59 Filename:·Assembly-CSharp/AirshipAuthGame.cs59 Filename:·Assembly-CSharp/AirshipAuthGame.cs
60 Comment:·60 Comment:·
Offset 93, 14 lines modifiedOffset 93, 71 lines modified
  
93 Filename:·Assembly-CSharp/AmbientSoundPlayer.cs93 Filename:·Assembly-CSharp/AmbientSoundPlayer.cs
94 Comment:·94 Comment:·
  
95 Filename:·Assembly-CSharp/Amongus/95 Filename:·Assembly-CSharp/Amongus/
96 Comment:·96 Comment:·
  
 97 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/
 98 Comment:·
  
 99 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AbstractAnimationTestScenePage.cs
 100 Comment:·
  
 101 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScene.cs
 102 Comment:·
  
 103 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneButton.cs
 104 Comment:·
  
 105 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPage.cs
 106 Comment:·
  
 107 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageBuilder.cs
 108 Comment:·
  
 109 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageBuilderPresetButton.cs
 110 Comment:·
  
 111 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageBuilderSprite.cs
 112 Comment:·
  
 113 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneColorsPageRenderer.cs
 114 Comment:·
  
 115 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneCosmeticData.cs
 116 Comment:·
  
 117 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneEjectPage.cs
 118 Comment:·
  
 119 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneExitPage.cs
 120 Comment:·
  
 121 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneInfoPage.cs
 122 Comment:·
  
 123 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneKillPage.cs
 124 Comment:·
  
 125 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneMeetingPage.cs
 126 Comment:·
  
 127 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScenePetsPage.cs
 128 Comment:·
  
 129 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScenePlayerPage.cs
 130 Comment:·
  
 131 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestScenePlayerPageBodyToggle.cs
 132 Comment:·
  
 133 Filename:·Assembly-CSharp/Amongus/AnimationTestScene/AnimationTestSceneTab.cs
 134 Comment:·
  
97 Filename:·Assembly-CSharp/Amongus/Data/135 Filename:·Assembly-CSharp/Amongus/Data/
98 Comment:·136 Comment:·
  
99 Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveData.cs137 Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveData.cs
100 Comment:·138 Comment:·
  
101 Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveDataGroup.cs139 Filename:·Assembly-CSharp/Amongus/Data/AbstractSaveDataGroup.cs
Offset 201, 14 lines modifiedOffset 258, 17 lines modified
  
201 Filename:·Assembly-CSharp/Amongus/GameOptions/ByteOptionNames.cs258 Filename:·Assembly-CSharp/Amongus/GameOptions/ByteOptionNames.cs
202 Comment:·259 Comment:·
  
203 Filename:·Assembly-CSharp/Amongus/GameOptions/EngineerRoleOptionsV07.cs260 Filename:·Assembly-CSharp/Amongus/GameOptions/EngineerRoleOptionsV07.cs
204 Comment:·261 Comment:·
  
 262 Filename:·Assembly-CSharp/Amongus/GameOptions/EngineerRoleOptionsV08.cs
 263 Comment:·
  
205 Filename:·Assembly-CSharp/Amongus/GameOptions/FloatArrayOptionNames.cs264 Filename:·Assembly-CSharp/Amongus/GameOptions/FloatArrayOptionNames.cs
206 Comment:·265 Comment:·
  
207 Filename:·Assembly-CSharp/Amongus/GameOptions/FloatOptionNames.cs266 Filename:·Assembly-CSharp/Amongus/GameOptions/FloatOptionNames.cs
208 Comment:·267 Comment:·
  
209 Filename:·Assembly-CSharp/Amongus/GameOptions/GameKeywords.cs268 Filename:·Assembly-CSharp/Amongus/GameOptions/GameKeywords.cs
Offset 222, 20 lines modifiedOffset 282, 29 lines modified
  
222 Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsFactory.cs282 Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsFactory.cs
223 Comment:·283 Comment:·
  
224 Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsMigratorV06toV07.cs284 Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsMigratorV06toV07.cs
225 Comment:·285 Comment:·
  
 286 Filename:·Assembly-CSharp/Amongus/GameOptions/GameOptionsMigratorV07toV08.cs
 287 Comment:·
  
226 Filename:·Assembly-CSharp/Amongus/GameOptions/GuardianAngelRoleOptionsV07.cs288 Filename:·Assembly-CSharp/Amongus/GameOptions/GuardianAngelRoleOptionsV07.cs
227 Comment:·289 Comment:·
  
 290 Filename:·Assembly-CSharp/Amongus/GameOptions/GuardianAngelRoleOptionsV08.cs
 291 Comment:·
  
228 Filename:·Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV07.cs292 Filename:·Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV07.cs
229 Comment:·293 Comment:·
  
 294 Filename:·Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV08.cs
 295 Comment:·
Max diff block lines reached; 13925/17717 bytes (78.60%) of diff not shown.
5.5 MB
zipdetails --redact --scan --utc {}
    
Offset 1, 67599 lines modifiedOffset 1, 71149 lines modified
  
1 000000·LOCAL·HEADER·#1·······04034B501 000000·LOCAL·HEADER·#1·······04034B50
2 000004·Extract·Zip·Spec······0A·'1.0'2 000004·Extract·Zip·Spec······0A·'1.0'
3 000005·Extract·OS············00·'MS-DOS'3 000005·Extract·OS············00·'MS-DOS'
4 000006·General·Purpose·Flag··00004 000006·General·Purpose·Flag··0000
5 000008·Compression·Method····0000·'Stored'5 000008·Compression·Method····0000·'Stored'
6 00000A·Last·Mod·Time·········5925AAF6·'Thu·Sep··5·21:23:44·2024'6 00000A·Last·Mod·Time·········5924B28E·'Wed·Sep··4·22:20:28·2024'
7 00000E·CRC···················000000007 00000E·CRC···················00000000
8 000012·Compressed·Length·····000000008 000012·Compressed·Length·····00000000
9 000016·Uncompressed·Length···000000009 000016·Uncompressed·Length···00000000
10 00001A·Filename·Length·······001010 00001A·Filename·Length·······0010
11 00001C·Extra·Length··········000011 00001C·Extra·Length··········0000
12 00001E·Filename··············'XXXXXXXXXXXXXXX/'12 00001E·Filename··············'XXXXXXXXXXXXXXX/'
  
13 00002E·LOCAL·HEADER·#2·······04034B5013 00002E·LOCAL·HEADER·#2·······04034B50
14 000032·Extract·Zip·Spec······14·'2.0'14 000032·Extract·Zip·Spec······14·'2.0'
15 000033·Extract·OS············00·'MS-DOS'15 000033·Extract·OS············00·'MS-DOS'
16 000034·General·Purpose·Flag··000016 000034·General·Purpose·Flag··0000
17 ·······[Bits·1-2]············0·'Normal·Compression'17 ·······[Bits·1-2]············0·'Normal·Compression'
18 000036·Compression·Method····0008·'Deflated'18 000036·Compression·Method····0008·'Deflated'
19 000038·Last·Mod·Time·········5925AAF3·'Thu·Sep··5·21:23:38·2024'19 000038·Last·Mod·Time·········5924B28A·'Wed·Sep··4·22:20:20·2024'
20 00003C·CRC···················6540C0FC20 00003C·CRC···················5B29D606
21 000040·Compressed·Length·····0000025021 000040·Compressed·Length·····00000264
22 000044·Uncompressed·Length···0000052622 000044·Uncompressed·Length···000005C8
23 000048·Filename·Length·······002023 000048·Filename·Length·······0020
24 00004A·Extra·Length··········000024 00004A·Extra·Length··········0000
25 00004C·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXX'25 00004C·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXX'
26 00006C·PAYLOAD26 00006C·PAYLOAD
  
27 0002BC·LOCAL·HEADER·#3·······04034B5027 0002D0·LOCAL·HEADER·#3·······04034B50
28 0002C0·Extract·Zip·Spec······14·'2.0'28 0002D4·Extract·Zip·Spec······14·'2.0'
29 0002C1·Extract·OS············00·'MS-DOS'29 0002D5·Extract·OS············00·'MS-DOS'
30 0002C2·General·Purpose·Flag··000030 0002D6·General·Purpose·Flag··0000
31 ·······[Bits·1-2]············0·'Normal·Compression'31 ·······[Bits·1-2]············0·'Normal·Compression'
32 0002C4·Compression·Method····0008·'Deflated'32 0002D8·Compression·Method····0008·'Deflated'
33 0002C6·Last·Mod·Time·········5925AAF3·'Thu·Sep··5·21:23:38·2024'33 0002DA·Last·Mod·Time·········5924B28A·'Wed·Sep··4·22:20:20·2024'
34 0002CA·CRC···················6653CC5434 0002DE·CRC···················4342EE09
35 0002CE·Compressed·Length·····0000009B35 0002E2·Compressed·Length·····000000A2
36 0002D2·Uncompressed·Length···000000CE36 0002E6·Uncompressed·Length···000000ED
37 0002D6·Filename·Length·······002837 0002EA·Filename·Length·······0028
38 0002D8·Extra·Length··········000038 0002EC·Extra·Length··········0000
39 0002DA·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX39 0002EE·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX
40 ·····························X'40 ·····························X'
41 000302·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX41 000316·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
42 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX42 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
43 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX43 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
44 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX44 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 45 ·····························XX
  
45 00039D·LOCAL·HEADER·#4·······04034B5046 0003B8·LOCAL·HEADER·#4·······04034B50
46 0003A1·Extract·Zip·Spec······14·'2.0'47 0003BC·Extract·Zip·Spec······14·'2.0'
47 0003A2·Extract·OS············00·'MS-DOS'48 0003BD·Extract·OS············00·'MS-DOS'
48 0003A3·General·Purpose·Flag··000049 0003BE·General·Purpose·Flag··0000
49 ·······[Bits·1-2]············0·'Normal·Compression'50 ·······[Bits·1-2]············0·'Normal·Compression'
50 0003A5·Compression·Method····0008·'Deflated'51 0003C0·Compression·Method····0008·'Deflated'
51 0003A7·Last·Mod·Time·········5925AAF3·'Thu·Sep··5·21:23:38·2024'52 0003C2·Last·Mod·Time·········5924B28A·'Wed·Sep··4·22:20:20·2024'
52 0003AB·CRC···················F9135BBF53 0003C6·CRC···················F9135BBF
53 0003AF·Compressed·Length·····000002FE54 0003CA·Compressed·Length·····000002FE
54 0003B3·Uncompressed·Length···0000097C55 0003CE·Uncompressed·Length···0000097C
55 0003B7·Filename·Length·······002956 0003D2·Filename·Length·······0029
56 0003B9·Extra·Length··········000057 0003D4·Extra·Length··········0000
57 0003BB·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX58 0003D6·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX
58 ·····························XX'59 ·····························XX'
59 0003E4·PAYLOAD60 0003FF·PAYLOAD
  
60 0006E2·LOCAL·HEADER·#5·······04034B5061 0006FD·LOCAL·HEADER·#5·······04034B50
61 0006E6·Extract·Zip·Spec······14·'2.0'62 000701·Extract·Zip·Spec······14·'2.0'
62 0006E7·Extract·OS············00·'MS-DOS'63 000702·Extract·OS············00·'MS-DOS'
63 0006E8·General·Purpose·Flag··000064 000703·General·Purpose·Flag··0000
64 ·······[Bits·1-2]············0·'Normal·Compression'65 ·······[Bits·1-2]············0·'Normal·Compression'
65 0006EA·Compression·Method····0008·'Deflated'66 000705·Compression·Method····0008·'Deflated'
66 0006EC·Last·Mod·Time·········5925AAF2·'Thu·Sep··5·21:23:36·2024'67 000707·Last·Mod·Time·········5924B288·'Wed·Sep··4·22:20:16·2024'
67 0006F0·CRC···················BD449E3668 00070B·CRC···················BFAB7C8F
68 0006F4·Compressed·Length·····0000011469 00070F·Compressed·Length·····00000125
69 0006F8·Uncompressed·Length···0000022370 000713·Uncompressed·Length···00000289
70 0006FC·Filename·Length·······002871 000717·Filename·Length·······0028
71 0006FE·Extra·Length··········000072 000719·Extra·Length··········0000
72 000700·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX73 00071B·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX
73 ·····························X'74 ·····························X'
74 000728·PAYLOAD75 000743·PAYLOAD
  
75 00083C·LOCAL·HEADER·#6·······04034B5076 000868·LOCAL·HEADER·#6·······04034B50
76 000840·Extract·Zip·Spec······14·'2.0'77 00086C·Extract·Zip·Spec······14·'2.0'
77 000841·Extract·OS············00·'MS-DOS'78 00086D·Extract·OS············00·'MS-DOS'
78 000842·General·Purpose·Flag··000079 00086E·General·Purpose·Flag··0000
79 ·······[Bits·1-2]············0·'Normal·Compression'80 ·······[Bits·1-2]············0·'Normal·Compression'
80 000844·Compression·Method····0008·'Deflated'81 000870·Compression·Method····0008·'Deflated'
81 000846·Last·Mod·Time·········5925AAF2·'Thu·Sep··5·21:23:36·2024'82 000872·Last·Mod·Time·········5924B289·'Wed·Sep··4·22:20:18·2024'
82 00084A·CRC···················B10C949C83 000876·CRC···················B10C949C
83 00084E·Compressed·Length·····0000006784 00087A·Compressed·Length·····00000067
84 000852·Uncompressed·Length···0000007085 00087E·Uncompressed·Length···00000070
85 000856·Filename·Length·······002D86 000882·Filename·Length·······002D
86 000858·Extra·Length··········000087 000884·Extra·Length··········0000
87 00085A·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX88 000886·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX
88 ·····························XXXXXX'89 ·····························XXXXXX'
89 000887·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX90 0008B3·PAYLOAD···············XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
90 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX91 ·····························XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
91 ·····························XXXXXXXXXXXXXXXXXXXXXXX92 ·····························XXXXXXXXXXXXXXXXXXXXXXX
  
92 0008EE·LOCAL·HEADER·#7·······04034B5093 00091A·LOCAL·HEADER·#7·······04034B50
93 0008F2·Extract·Zip·Spec······14·'2.0'94 00091E·Extract·Zip·Spec······14·'2.0'
94 0008F3·Extract·OS············00·'MS-DOS'95 00091F·Extract·OS············00·'MS-DOS'
95 0008F4·General·Purpose·Flag··000096 000920·General·Purpose·Flag··0000
96 ·······[Bits·1-2]············0·'Normal·Compression'97 ·······[Bits·1-2]············0·'Normal·Compression'
97 0008F6·Compression·Method····0008·'Deflated'98 000922·Compression·Method····0008·'Deflated'
98 0008F8·Last·Mod·Time·········5925AAF4·'Thu·Sep··5·21:23:40·2024'99 000924·Last·Mod·Time·········5924B28B·'Wed·Sep··4·22:20:22·2024'
99 0008FC·CRC···················33E98826100 000928·CRC···················33E98826
100 000900·Compressed·Length·····000003EA101 00092C·Compressed·Length·····000003EA
101 000904·Uncompressed·Length···00000B73102 000930·Uncompressed·Length···00000B73
102 000908·Filename·Length·······0028103 000934·Filename·Length·······0028
103 00090A·Extra·Length··········0000104 000936·Extra·Length··········0000
104 00090C·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX105 000938·Filename··············'XXXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXX
105 ·····························X'106 ·····························X'
106 000934·PAYLOAD107 000960·PAYLOAD
  
107 000D1E·LOCAL·HEADER·#8·······04034B50108 000D4A·LOCAL·HEADER·#8·······04034B50
108 000D22·Extract·Zip·Spec······14·'2.0'109 000D4E·Extract·Zip·Spec······14·'2.0'
109 000D23·Extract·OS············00·'MS-DOS'110 000D4F·Extract·OS············00·'MS-DOS'
110 000D24·General·Purpose·Flag··0000111 000D50·General·Purpose·Flag··0000
111 ·······[Bits·1-2]············0·'Normal·Compression'112 ·······[Bits·1-2]············0·'Normal·Compression'
112 000D26·Compression·Method····0008·'Deflated'113 000D52·Compression·Method····0008·'Deflated'
113 000D28·Last·Mod·Time·········5925AAF0·'Thu·Sep··5·21:23:32·2024'114 000D54·Last·Mod·Time·········5924B287·'Wed·Sep··4·22:20:14·2024'
114 000D2C·CRC···················53019761115 000D58·CRC···················53019761
115 000D30·Compressed·Length·····00000109116 000D5C·Compressed·Length·····00000109
116 000D34·Uncompressed·Length···000001B5117 000D60·Uncompressed·Length···000001B5
117 000D38·Filename·Length·······0020118 000D64·Filename·Length·······0020
118 000D3A·Extra·Length··········0000119 000D66·Extra·Length··········0000
Max diff block lines reached; 5750386/5763437 bytes (99.77%) of diff not shown.
733 B
Assembly-CSharp/AbilityButton.cs
    
Offset 40, 14 lines modifiedOffset 40, 20 lines modified
40 »       »       base.SetInfiniteUses();40 »       »       base.SetInfiniteUses();
41 »       »       this.graphic.sprite·=·settings.Image;41 »       »       this.graphic.sprite·=·settings.Image;
42 »       »       this.graphic.SetCooldownNormalizedUvs();42 »       »       this.graphic.SetCooldownNormalizedUvs();
43 »       »       this.buttonLabelText.fontSharedMaterial·=·settings.FontMaterial;43 »       »       this.buttonLabelText.fontSharedMaterial·=·settings.FontMaterial;
44 »       »       this.buttonLabelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(settings.Text,·Array.Empty<object>());44 »       »       this.buttonLabelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(settings.Text,·Array.Empty<object>());
45 »       }45 »       }
46 46
 47 »       public·void·SetSecondImage(AbilityButtonSettings·settings)
 48 »       {
 49 »       »       this.graphic.sprite·=·settings.SecondImage;
 50 »       »       this.graphic.SetCooldownNormalizedUvs();
 51 »       }
 52
47 »       private·void·Update()53 »       private·void·Update()
48 »       {54 »       {
49 »       »       if·(PlayerControl.LocalPlayer.Data.Role.IsAffectedByComms)55 »       »       if·(PlayerControl.LocalPlayer.Data.Role.IsAffectedByComms)
50 »       »       {56 »       »       {
51 »       »       »       this.commsDown.SetActive(true);57 »       »       »       this.commsDown.SetActive(true);
52 »       »       »       return;58 »       »       »       return;
53 »       »       }59 »       »       }
330 B
Assembly-CSharp/AbilityButtonSettings.cs
    
Offset 2, 11 lines modifiedOffset 2, 13 lines modified
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 [CreateAssetMenu]4 [CreateAssetMenu]
5 public·class·AbilityButtonSettings·:·ScriptableObject5 public·class·AbilityButtonSettings·:·ScriptableObject
6 {6 {
7 »       public·Sprite·Image;7 »       public·Sprite·Image;
8 8
 9 »       public·Sprite·SecondImage;
 10
9 »       public·StringNames·Text;11 »       public·StringNames·Text;
10 12
11 »       public·Material·FontMaterial;13 »       public·Material·FontMaterial;
12 }14 }
371 B
Assembly-CSharp/AbstractCosmeticGroup.cs
    
Offset 26, 10 lines modifiedOffset 26, 15 lines modified
26 »       }26 »       }
27 27
28 »       public·bool·Contains(string·id)28 »       public·bool·Contains(string·id)
29 »       {29 »       {
30 »       »       return·this.ids.Contains(id);30 »       »       return·this.ids.Contains(id);
31 »       }31 »       }
32 32
 33 »       public·int·IndexOf(CosmeticData·cosmetic)
 34 »       {
 35 »       »       return·this.ids.IndexOf(cosmetic.ProductId);
 36 »       }
 37
33 »       [SerializeField]38 »       [SerializeField]
34 »       private·List<string>·ids·=·new·List<string>();39 »       private·List<string>·ids·=·new·List<string>();
35 }40 }
1.66 KB
Assembly-CSharp/AccountTab.cs
    
Offset 175, 26 lines modifiedOffset 175, 29 lines modified
175 »       }175 »       }
176 176
177 »       private·void·UpdateAccountIDDisplay()177 »       private·void·UpdateAccountIDDisplay()
178 »       {178 »       {
179 »       »       if·(string.IsNullOrEmpty(DestroyableSingleton<EOSManager>.Instance.ProductUserId))179 »       »       if·(string.IsNullOrEmpty(DestroyableSingleton<EOSManager>.Instance.ProductUserId))
180 »       »       {180 »       »       {
181 »       »       »       this.showAccountID·=·false;181 »       »       »       this.showAccountID·=·false;
 182 »       »       »       this.accountCopyButton.SetActive(false);
182 »       »       »       this.showAccountIDButton.gameObject.SetActive(false);183 »       »       »       this.showAccountIDButton.gameObject.SetActive(false);
183 »       »       »       this.accountIDDisplayText.text·=·"";184 »       »       »       this.accountIDDisplayText.text·=·"";
184 »       »       »       return;185 »       »       »       return;
185 »       »       }186 »       »       }
186 »       »       if·(this.showAccountID)187 »       »       if·(this.showAccountID)
187 »       »       {188 »       »       {
188 »       »       »       this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<EOSManager>.Instance.ProductUserId·});189 »       »       »       this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<EOSManager>.Instance.ProductUserId·});
189 »       »       »       this.showAccountIDButton.gameObject.SetActive(false);190 »       »       »       this.showAccountIDButton.gameObject.SetActive(false);
 191 »       »       »       this.accountCopyButton.SetActive(true);
190 »       »       »       return;192 »       »       »       return;
191 »       »       }193 »       »       }
192 »       »       this.showAccountIDButton.gameObject.SetActive(true);194 »       »       this.showAccountIDButton.gameObject.SetActive(true);
193 »       »       this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HiddenAccountID,·Array.Empty<object>())·});195 »       »       this.accountIDDisplayText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.AccountIDDisplay,·new·object[]·{·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HiddenAccountID,·Array.Empty<object>())·});
 196 »       »       this.accountCopyButton.SetActive(false);
194 »       }197 »       }
195 198
196 »       public·void·HideAccountIDDisplay()199 »       public·void·HideAccountIDDisplay()
197 »       {200 »       {
198 »       »       this.showAccountID·=·false;201 »       »       this.showAccountID·=·false;
199 »       »       this.UpdateAccountIDDisplay();202 »       »       this.UpdateAccountIDDisplay();
200 »       }203 »       }
Offset 317, 14 lines modifiedOffset 320, 17 lines modified
317 »       public·SpriteRenderer·SpaceHorse;320 »       public·SpriteRenderer·SpaceHorse;
318 321
319 »       public·InfoTextBox·InfoTextBoxDisplay;322 »       public·InfoTextBox·InfoTextBoxDisplay;
320 323
321 »       [SerializeField]324 »       [SerializeField]
322 »       private·SignInStatusComponent·signInStatusComponent;325 »       private·SignInStatusComponent·signInStatusComponent;
323 326
 327 »       [SerializeField]
 328 »       private·GameObject·accountCopyButton;
 329
324 »       private·bool·showAccountID;330 »       private·bool·showAccountID;
325 331
326 »       private·string·friendCodeHiddenText·=·"XXXXXXXXXX";332 »       private·string·friendCodeHiddenText·=·"XXXXXXXXXX";
327 333
328 »       [Header("Console·Controller·Navigation")]334 »       [Header("Console·Controller·Navigation")]
329 »       public·UiElement·BackButton;335 »       public·UiElement·BackButton;
330 336
2.45 KB
Assembly-CSharp/AchievementManager.cs
    
Offset 137, 28 lines modifiedOffset 137, 28 lines modified
137 »       {137 »       {
138 »       »       if·(!this.gameStarted)138 »       »       if·(!this.gameStarted)
139 »       »       {139 »       »       {
140 »       »       »       return;140 »       »       »       return;
141 »       »       }141 »       »       }
142 »       »       this.logger.Info("Match·ended",·null);142 »       »       this.logger.Info("Match·ended",·null);
143 »       »       this.gameStarted·=·false;143 »       »       this.gameStarted·=·false;
144 »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data; 
145 »       »       bool·flag·=·data·!=·null·&&·data.Role.IsImpostor;144 »       »       CachedPlayerData·cachedLocalPlayer·=·EndGameResult.CachedLocalPlayer;
 145 »       »       bool·flag·=·cachedLocalPlayer·!=·null·&&·cachedLocalPlayer.IsImpostor;
146 »       »       if·(flag)146 »       »       if·(flag)
147 »       »       {147 »       »       {
148 »       »       »       if·(this.ventsUsedThisMatch·==·0·&&·GameManager.Instance.DidImpostorsWin(reason))148 »       »       »       if·(this.ventsUsedThisMatch·==·0·&&·GameManager.Instance.DidImpostorsWin(reason))
149 »       »       »       {149 »       »       »       {
150 »       »       »       »       this.UnlockAchievement("no_vents_impostor_win");150 »       »       »       »       this.UnlockAchievement("no_vents_impostor_win");
151 »       »       »       }151 »       »       »       }
152 »       »       »       IEnumerable<GameData.PlayerInfo>·enumerable·=·Enumerable.Where<GameData.PlayerInfo>(GameData.Instance.AllPlayers,·(GameData.PlayerInfo·p)·=>·p.Role.IsImpostor);152 »       »       »       IEnumerable<NetworkedPlayerInfo>·enumerable·=·Enumerable.Where<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Role.IsImpostor);
153 »       »       »       int·num·=·Enumerable.Count<GameData.PlayerInfo>(enumerable);153 »       »       »       int·num·=·Enumerable.Count<NetworkedPlayerInfo>(enumerable);
154 »       »       »       bool·flag2;154 »       »       »       bool·flag2;
155 »       »       »       if·(num·==·2)155 »       »       »       if·(num·==·2)
156 »       »       »       {156 »       »       »       {
157 »       »       »       »       flag2·=·num·==·Enumerable.Count<GameData.PlayerInfo>(enumerable,·(GameData.PlayerInfo·p)·=>·!p.IsDead·&&·!p.Disconnected);157 »       »       »       »       flag2·=·num·==·Enumerable.Count<NetworkedPlayerInfo>(enumerable,·(NetworkedPlayerInfo·p)·=>·!p.IsDead·&&·!p.Disconnected);
158 »       »       »       }158 »       »       »       }
159 »       »       »       else159 »       »       »       else
160 »       »       »       {160 »       »       »       {
161 »       »       »       »       flag2·=·false;161 »       »       »       »       flag2·=·false;
162 »       »       »       }162 »       »       »       }
163 »       »       »       if·(flag2·&&·didWin)163 »       »       »       if·(flag2·&&·didWin)
164 »       »       »       {164 »       »       »       {
Offset 182, 16 lines modifiedOffset 182, 16 lines modified
182 »       »       »       }182 »       »       »       }
183 »       »       }183 »       »       }
184 »       »       else184 »       »       else
185 »       »       {185 »       »       {
186 »       »       »       if·(GameManager.Instance.DidHumansWin(reason))186 »       »       »       if·(GameManager.Instance.DidHumansWin(reason))
187 »       »       »       {187 »       »       »       {
188 »       »       »       »       this.UpdateAchievementProgress("hnsCrewmateWin",·1);188 »       »       »       »       this.UpdateAchievementProgress("hnsCrewmateWin",·1);
189 »       »       »       »       GameData.PlayerInfo·data2·=·PlayerControl.LocalPlayer.Data; 
190 »       »       »       »       if·(data2·!=·null·&&·!data2.IsDead)189 »       »       »       »       CachedPlayerData·cachedLocalPlayer2·=·EndGameResult.CachedLocalPlayer;
 190 »       »       »       »       if·(cachedLocalPlayer2·!=·null·&&·!cachedLocalPlayer2.IsDead)
191 »       »       »       »       {191 »       »       »       »       {
192 »       »       »       »       »       this.UnlockAchievement("survive_crewmate");192 »       »       »       »       »       this.UnlockAchievement("survive_crewmate");
193 »       »       »       »       »       this.UnlockAchievement("hns_survive_crewmate");193 »       »       »       »       »       this.UnlockAchievement("hns_survive_crewmate");
194 »       »       »       »       }194 »       »       »       »       }
195 »       »       »       }195 »       »       »       }
196 »       »       »       if·(reason·==·GameOverReason.HumansByTask)196 »       »       »       if·(reason·==·GameOverReason.HumansByTask)
197 »       »       »       {197 »       »       »       {
Offset 302, 15 lines modifiedOffset 302, 15 lines modified
302 »       }302 »       }
303 303
304 »       public·void·OnProtectACrewmate()304 »       public·void·OnProtectACrewmate()
305 »       {305 »       {
306 »       »       this.UnlockAchievement("block_kill_as_guardian");306 »       »       this.UnlockAchievement("block_kill_as_guardian");
307 »       }307 »       }
308 308
309 »       public·void·OnMeetingVote(GameData.PlayerInfo·self,·GameData.PlayerInfo·target)309 »       public·void·OnMeetingVote(NetworkedPlayerInfo·self,·NetworkedPlayerInfo·target)
310 »       {310 »       {
311 »       »       if·(!this.gameStarted)311 »       »       if·(!this.gameStarted)
312 »       »       {312 »       »       {
313 »       »       »       return;313 »       »       »       return;
314 »       »       }314 »       »       }
315 »       »       if·(target·==·null)315 »       »       if·(target·==·null)
316 »       »       {316 »       »       {
419 B
Assembly-CSharp/ActionButton.cs
    
Offset 1, 13 lines modifiedOffset 1, 21 lines modified
1 using·System;1 using·System;
2 using·TMPro;2 using·TMPro;
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·abstract·class·ActionButton·:·MonoBehaviour5 public·abstract·class·ActionButton·:·MonoBehaviour
6 {6 {
 7 »       public·bool·IsOnCooldown
 8 »       {
 9 »       »       get
 10 »       »       {
 11 »       »       »       return·this.isCoolingDown;
 12 »       »       }
 13 »       }
 14
7 »       private·void·Start()15 »       private·void·Start()
8 »       {16 »       {
9 »       »       this.position·=·this.graphic.transform.localPosition;17 »       »       this.position·=·this.graphic.transform.localPosition;
10 »       }18 »       }
11 19
12 »       public·abstract·void·DoClick();20 »       public·abstract·void·DoClick();
13 21
2.88 KB
Assembly-CSharp/ActionMapGlyphDisplay.cs
    
Offset 1, 58 lines modifiedOffset 1, 88 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
 3 using·UnityEngine.UI;
3 4
4 [RequireComponent(typeof(SpriteRenderer))] 
5 public·class·ActionMapGlyphDisplay·:·MonoBehaviour5 public·class·ActionMapGlyphDisplay·:·MonoBehaviour
6 {6 {
7 »       private·void·Awake()7 »       private·void·Awake()
8 »       {8 »       {
9 »       »       this.sr·=·base.GetComponent<SpriteRenderer>();9 »       »       this.spriteRenderer·=·base.GetComponent<SpriteRenderer>();
 10 »       »       this.uiImage·=·base.GetComponent<Image>();
10 »       »       this.UpdateGlyphDisplay();11 »       »       this.UpdateGlyphDisplay();
11 »       »       ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Combine(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay));12 »       »       ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Combine(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay));
12 »       }13 »       }
13 14
14 »       private·void·OnDestroy()15 »       private·void·OnDestroy()
15 »       {16 »       {
16 »       »       ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Remove(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay));17 »       »       ActiveInputManager.CurrentInputSourceChanged·=·(Action)Delegate.Remove(ActiveInputManager.CurrentInputSourceChanged,·new·Action(this.UpdateGlyphDisplay));
17 »       }18 »       }
18 19
19 »       public·void·UpdateGlyphDisplay()20 »       public·void·UpdateGlyphDisplay()
20 »       {21 »       {
21 »       »       if·(this.sr)22 »       »       if·(this.spriteRenderer)
22 »       »       {23 »       »       {
23 »       »       »       this.sr.gameObject.SetActive(false);24 »       »       »       this.spriteRenderer.gameObject.SetActive(false);
24 »       »       }25 »       »       }
 26 »       »       if·(this.uiImage)
 27 »       »       {
 28 »       »       »       this.uiImage.gameObject.SetActive(false);
 29 »       »       }
25 »       »       if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick·&&·this.sr)30 »       »       if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick)
26 »       »       {31 »       »       {
27 »       »       »       this.sr.gameObject.SetActive(true); 
28 »       »       »       GlyphCollection.ErrorCode·errorCode;32 »       »       »       GlyphCollection.ErrorCode·errorCode;
29 »       »       »       Sprite·sprite·=·GlyphCollection.FindGlyph((int)this.actionToDisplayMappedGlyphFor,·out·errorCode);33 »       »       »       Sprite·sprite·=·GlyphCollection.FindGlyph((int)this.actionToDisplayMappedGlyphFor,·out·errorCode);
30 »       »       »       if·(errorCode·!=·GlyphCollection.ErrorCode.NoController)34 »       »       »       if·(this.spriteRenderer)
31 »       »       »       {35 »       »       »       {
 36 »       »       »       »       this.spriteRenderer.gameObject.SetActive(true);
 37 »       »       »       »       if·(errorCode·!=·GlyphCollection.ErrorCode.NoController)
 38 »       »       »       »       {
 39 »       »       »       »       »       this.spriteRenderer.sprite·=·sprite;
 40 »       »       »       »       }
 41 »       »       »       »       else
 42 »       »       »       »       {
 43 »       »       »       »       »       this.spriteRenderer.gameObject.SetActive(false);
 44 »       »       »       »       }
 45 »       »       »       }
 46 »       »       »       if·(this.uiImage)
 47 »       »       »       {
 48 »       »       »       »       this.uiImage.gameObject.SetActive(true);
 49 »       »       »       »       if·(errorCode·!=·GlyphCollection.ErrorCode.NoController)
 50 »       »       »       »       {
32 »       »       »       »       this.sr.sprite·=·sprite;51 »       »       »       »       »       this.uiImage.sprite·=·sprite;
33 »       »       »       »       return;52 »       »       »       »       »       return;
 53 »       »       »       »       }
 54 »       »       »       »       this.uiImage.gameObject.SetActive(false);
34 »       »       »       }55 »       »       »       }
35 »       »       »       this.sr.gameObject.SetActive(false); 
36 »       »       }56 »       »       }
37 »       }57 »       }
38 58
39 »       public·void·SetColor(Color·color)59 »       public·void·SetColor(Color·color)
40 »       {60 »       {
41 »       »       if·(this.sr)61 »       »       if·(this.spriteRenderer)
42 »       »       {62 »       »       {
 63 »       »       »       this.spriteRenderer.color·=·color;
 64 »       »       }
 65 »       »       if·(this.uiImage)
 66 »       »       {
43 »       »       »       this.sr.color·=·color;67 »       »       »       this.uiImage.color·=·color;
44 »       »       }68 »       »       }
45 »       }69 »       }
46 70
47 »       public·void·SetSpriteVisibility(bool·visible)71 »       public·void·SetSpriteVisibility(bool·visible)
48 »       {72 »       {
 73 »       »       if·(this.spriteRenderer·!=·null)
 74 »       »       {
 75 »       »       »       this.spriteRenderer.enabled·=·visible;
 76 »       »       }
49 »       »       if·(this.sr·!=·null)77 »       »       if·(this.uiImage·!=·null)
50 »       »       {78 »       »       {
51 »       »       »       this.sr.enabled·=·visible;79 »       »       »       this.uiImage.enabled·=·visible;
52 »       »       }80 »       »       }
53 »       }81 »       }
54 82
55 »       public·RewiredConstsEnum.Action·actionToDisplayMappedGlyphFor;83 »       public·RewiredConstsEnum.Action·actionToDisplayMappedGlyphFor;
56 84
57 »       private·SpriteRenderer·sr;85 »       private·SpriteRenderer·spriteRenderer;
 86
 87 »       private·Image·uiImage;
58 }88 }
4.07 KB
Assembly-CSharp/AirshipExileController.cs
    
Offset 2, 36 lines modifiedOffset 2, 46 lines modified
2 using·System.Collections;2 using·System.Collections;
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·class·AirshipExileController·:·ExileController5 public·class·AirshipExileController·:·ExileController
6 {6 {
7 »       protected·override·IEnumerator·Animate()7 »       protected·override·IEnumerator·Animate()
8 »       {8 »       {
9 »       »       if·(this.exiled·!=·null)9 »       »       if·(this.initData·!=·null·&&·this.initData.outfit·!=·null)
10 »       »       {10 »       »       {
11 »       »       »       PlayerMaterial.SetColors(this.exiled.DefaultOutfit.ColorId,·this.HandSlot);11 »       »       »       PlayerMaterial.SetColors(this.initData.outfit.ColorId,·this.HandSlot);
12 »       »       }12 »       »       }
13 »       »       float·num·=·0.7f·+·this.Duration·+·0.5f·+·2f;13 »       »       float·num·=·0.7f·+·this.Duration·+·0.5f·+·2f;
14 »       »       base.StartCoroutine(Effects.All(new·IEnumerator[]14 »       »       base.StartCoroutine(Effects.All(new·IEnumerator[]
15 »       »       {15 »       »       {
16 »       »       »       this.SlowMoSlide2D(this.ForegroundCloud.transform,·new·Vector2(-1.4f,·-2.41f),·new·Vector2(-0.4f,·-2.41f),·num),16 »       »       »       this.SlowMoSlide2D(this.ForegroundCloud.transform,·new·Vector2(-1.4f,·-2.41f),·new·Vector2(-0.4f,·-2.41f),·num),
17 »       »       »       this.SlowMoSlide2D(this.BackgroundCloud.transform,·new·Vector2(-0.97f,·-1.043f),·new·Vector2(0.25f,·-1.043f),·num),17 »       »       »       this.SlowMoSlide2D(this.BackgroundCloud.transform,·new·Vector2(-0.97f,·-1.043f),·new·Vector2(0.25f,·-1.043f),·num),
18 »       »       »       this.SlowMoSlide2D(this.Cloud1.transform,·new·Vector2(3f,·0.25f),·new·Vector2(6.5f,·0.25f),·num),18 »       »       »       this.SlowMoSlide2D(this.Cloud1.transform,·new·Vector2(3f,·0.25f),·new·Vector2(6.5f,·0.25f),·num),
19 »       »       »       this.SlowMoSlide2D(this.Cloud2.transform,·new·Vector2(-6f,·3f),·new·Vector2(5f,·3f),·num),19 »       »       »       this.SlowMoSlide2D(this.Cloud2.transform,·new·Vector2(-6f,·3f),·new·Vector2(5f,·3f),·num),
20 »       »       »       this.SlowMoSlide2D(this.Cloud3.transform,·new·Vector2(-4f,·-2.2f),·new·Vector2(4f,·-2.2f),·num)20 »       »       »       this.SlowMoSlide2D(this.Cloud3.transform,·new·Vector2(-4f,·-2.2f),·new·Vector2(4f,·-2.2f),·num)
21 »       »       }));21 »       »       }));
 22 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 23 »       »       {
22 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);24 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);
 25 »       »       }
23 »       »       yield·return·Effects.Wait(0.5f);26 »       »       yield·return·Effects.Wait(0.5f);
24 »       »       yield·return·Effects.All(new·IEnumerator[]27 »       »       yield·return·Effects.All(new·IEnumerator[]
25 »       »       {28 »       »       {
26 »       »       »       this.PlayerFall(),29 »       »       »       this.PlayerFall(),
27 »       »       »       this.HandleText(1.75f,·this.Duration·*·0.5f)30 »       »       »       this.HandleText(1.75f,·this.Duration·*·0.5f)
28 »       »       });31 »       »       });
29 »       »       yield·return·new·WaitForSeconds(0.5f);32 »       »       yield·return·new·WaitForSeconds(0.5f);
 33 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 34 »       »       {
30 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);35 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);
 36 »       »       }
 37 »       »       else
 38 »       »       {
 39 »       »       »       yield·return·Effects.Wait(0.2f);
 40 »       »       }
31 »       »       yield·return·this.WrapUpAndSpawn();41 »       »       yield·return·this.WrapUpAndSpawn();
32 »       »       yield·break;42 »       »       yield·break;
33 »       }43 »       }
34 44
35 »       private·IEnumerator·SlowMoSlide2D(Transform·target,·Vector2·source,·Vector2·dest,·float·duration)45 »       private·IEnumerator·SlowMoSlide2D(Transform·target,·Vector2·source,·Vector2·dest,·float·duration)
36 »       {46 »       {
37 »       »       Vector3·temp·=·default(Vector3);47 »       »       Vector3·temp·=·default(Vector3);
Offset 48, 36 lines modifiedOffset 58, 36 lines modified
48 »       »       temp.y·=·dest.y;58 »       »       temp.y·=·dest.y;
49 »       »       target.localPosition·=·temp;59 »       »       target.localPosition·=·temp;
50 »       »       yield·break;60 »       »       yield·break;
51 »       }61 »       }
52 62
53 »       protected·IEnumerator·WrapUpAndSpawn()63 »       protected·IEnumerator·WrapUpAndSpawn()
54 »       {64 »       {
55 »       »       if·(this.exiled·!=·null)65 »       »       if·(this.initData·!=·null·&&·this.initData.networkedPlayer·!=·null)
56 »       »       {66 »       »       {
57 »       »       »       PlayerControl·@object·=·this.exiled.Object;67 »       »       »       PlayerControl·@object·=·this.initData.networkedPlayer.Object;
58 »       »       »       if·(@object)68 »       »       »       if·(@object)
59 »       »       »       {69 »       »       »       {
60 »       »       »       »       @object.Exiled();70 »       »       »       »       @object.Exiled();
61 »       »       »       }71 »       »       »       }
62 »       »       »       this.exiled.IsDead·=·true;72 »       »       »       this.initData.networkedPlayer.IsDead·=·true;
63 »       »       }73 »       »       }
64 »       »       if·(DestroyableSingleton<TutorialManager>.InstanceExists·||·!GameManager.Instance.LogicFlow.IsGameOverDueToDeath())74 »       »       if·(DestroyableSingleton<TutorialManager>.InstanceExists·||·(GameManager.Instance·!=·null·&&·!GameManager.Instance.LogicFlow.IsGameOverDueToDeath()))
65 »       »       {75 »       »       {
66 »       »       »       yield·return·ShipStatus.Instance.PrespawnStep();76 »       »       »       yield·return·ShipStatus.Instance.PrespawnStep();
67 »       »       »       base.ReEnableGameplay();77 »       »       »       base.ReEnableGameplay();
68 »       »       }78 »       »       }
69 »       »       Object.Destroy(base.gameObject);79 »       »       Object.Destroy(base.gameObject);
70 »       »       yield·break;80 »       »       yield·break;
71 »       }81 »       }
72 82
73 »       protected·override·IEnumerator·HandleText(float·firstWaitTime,·float·animDuration)83 »       protected·override·IEnumerator·HandleText(float·firstWaitTime,·float·animDuration)
74 »       {84 »       {
75 »       »       yield·return·Effects.Wait(firstWaitTime);85 »       »       yield·return·Effects.Wait(firstWaitTime);
76 »       »       if·(this.exiled·!=·null)86 »       »       if·(this.initData·!=·null·&&·this.initData.outfit·!=·null)
77 »       »       {87 »       »       {
78 »       »       »       this.CloudSlowMo·=·0.1f;88 »       »       »       this.CloudSlowMo·=·0.1f;
79 »       »       »       this.PlayerSlowMo·=·0.1f;89 »       »       »       this.PlayerSlowMo·=·0.1f;
80 »       »       »       SoundManager.Instance.PlaySound(this.Stinger,·false,·1f,·null);90 »       »       »       SoundManager.Instance.PlaySound(this.Stinger,·false,·1f,·null);
81 »       »       }91 »       »       }
82 »       »       float·newDur·=·this.Duration·*·0.5f;92 »       »       float·newDur·=·this.Duration·*·0.5f;
83 »       »       for·(float·t·=·0f;·t·<=·newDur;·t·+=·Time.deltaTime)93 »       »       for·(float·t·=·0f;·t·<=·newDur;·t·+=·Time.deltaTime)
Offset 95, 15 lines modifiedOffset 105, 15 lines modified
95 »       »       »       yield·return·null;105 »       »       »       yield·return·null;
96 »       »       }106 »       »       }
97 »       »       this.Text.text·=·this.completeString;107 »       »       this.Text.text·=·this.completeString;
98 »       »       yield·return·Effects.Wait(1f);108 »       »       yield·return·Effects.Wait(1f);
99 »       »       this.CloudSlowMo·=·1f;109 »       »       this.CloudSlowMo·=·1f;
100 »       »       this.PlayerSlowMo·=·6f;110 »       »       this.PlayerSlowMo·=·6f;
101 »       »       yield·return·Effects.Wait(0.5f);111 »       »       yield·return·Effects.Wait(0.5f);
102 »       »       if·(GameManager.Instance.LogicOptions.GetConfirmImpostor())112 »       »       if·(this.initData.confirmImpostor)
103 »       »       {113 »       »       {
104 »       »       »       this.ImpostorText.gameObject.SetActive(true);114 »       »       »       this.ImpostorText.gameObject.SetActive(true);
105 »       »       }115 »       »       }
106 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);116 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);
107 »       »       yield·break;117 »       »       yield·break;
108 »       }118 »       }
109 119
667 B
Assembly-CSharp/AirshipStatus.cs
    
Offset 73, 15 lines modifiedOffset 73, 15 lines modified
73 »       }73 »       }
74 74
75 »       public·override·void·RepairCriticalSabotages()75 »       public·override·void·RepairCriticalSabotages()
76 »       {76 »       {
77 »       »       (ShipStatus.Instance.Systems[SystemTypes.HeliSabotage]·as·HeliSabotageSystem).ClearSabotage();77 »       »       (ShipStatus.Instance.Systems[SystemTypes.HeliSabotage]·as·HeliSabotageSystem).ClearSabotage();
78 »       }78 »       }
79 79
80 »       public·override·float·CalculateLightRadius(GameData.PlayerInfo·player)80 »       public·override·float·CalculateLightRadius(NetworkedPlayerInfo·player)
81 »       {81 »       {
82 »       »       float·num·=·base.CalculateLightRadius(player);82 »       »       float·num·=·base.CalculateLightRadius(player);
83 »       »       if·(player.Role.AffectedByLightAffectors)83 »       »       if·(player.Role.AffectedByLightAffectors)
84 »       »       {84 »       »       {
85 »       »       »       foreach·(LightAffector·lightAffector·in·this.LightAffectors)85 »       »       »       foreach·(LightAffector·lightAffector·in·this.LightAffectors)
86 »       »       »       {86 »       »       »       {
87 »       »       »       »       if·(player.Object·&&·player.Object.Collider.IsTouching(lightAffector.Hitbox))87 »       »       »       »       if·(player.Object·&&·player.Object.Collider.IsTouching(lightAffector.Hitbox))
1.66 KB
Assembly-CSharp/Amongus/Data/Player/PlayerData.cs
    
Offset 127, 23 lines modifiedOffset 127, 23 lines modified
127 »       »       »       »       DataManager.Logger.Error("[PlayerData::OnSaveStart()]·Failed·to·serialize·and·encrypt·PlayerAdsData.",·null);127 »       »       »       »       DataManager.Logger.Error("[PlayerData::OnSaveStart()]·Failed·to·serialize·and·encrypt·PlayerAdsData.",·null);
128 »       »       »       }128 »       »       »       }
129 »       »       }129 »       »       }
130 130
131 »       »       protected·override·void·OnLoadComplete()131 »       »       protected·override·void·OnLoadComplete()
132 »       »       {132 »       »       {
133 »       »       »       base.OnLoadComplete();133 »       »       »       base.OnLoadComplete();
134 »       »       »       this.purchases.UpdateLegacyPurchases(); 
135 »       »       »       if·(this.encryptedAge·!=·null·&&·this.encryptedAge.Length·!=·0)134 »       »       »       if·(this.encryptedAge·!=·null·&&·this.encryptedAge.Length·!=·0)
136 »       »       »       {135 »       »       »       {
137 »       »       »       »       base.TryDecryptAndDeserialize<PlayerAgeData>(ref·this.age,·this.encryptedAge);136 »       »       »       »       base.TryDecryptAndDeserialize<PlayerAgeData>(ref·this.age,·this.encryptedAge);
138 »       »       »       }137 »       »       »       }
139 »       »       »       if·(this.encryptedStore·!=·null·&&·this.encryptedStore.Length·!=·0)138 »       »       »       if·(this.encryptedStore·!=·null·&&·this.encryptedStore.Length·!=·0)
140 »       »       »       {139 »       »       »       {
141 »       »       »       »       base.TryDecryptAndDeserialize<PlayerStoreData>(ref·this.store,·this.encryptedStore);140 »       »       »       »       base.TryDecryptAndDeserialize<PlayerStoreData>(ref·this.store,·this.encryptedStore);
142 »       »       »       }141 »       »       »       }
 142 »       »       »       this.purchases.UpdateLegacyPurchases();
143 »       »       »       if·(this.encryptedAds·!=·null·&&·this.encryptedAds.Length·!=·0)143 »       »       »       if·(this.encryptedAds·!=·null·&&·this.encryptedAds.Length·!=·0)
144 »       »       »       {144 »       »       »       {
145 »       »       »       »       base.TryDecryptAndDeserialize<PlayerAdsData>(ref·this.ads,·this.encryptedAds);145 »       »       »       »       base.TryDecryptAndDeserialize<PlayerAdsData>(ref·this.ads,·this.encryptedAds);
146 »       »       »       }146 »       »       »       }
147 »       »       }147 »       »       }
148 148
149 »       »       protected·override·void·HandleVersionMigration(int·version)149 »       »       protected·override·void·HandleVersionMigration(int·version)
Offset 177, 15 lines modifiedOffset 177, 15 lines modified
177 »       »       »       »       »       }177 »       »       »       »       »       }
178 »       »       »       »       »       int[]·array·=·LegacySaveManager.LoadLocalDoB();178 »       »       »       »       »       int[]·array·=·LegacySaveManager.LoadLocalDoB();
179 »       »       »       »       »       if·(array.Length·==·3·&&·array[0]·>·0·&&·array[1]·>·0·&&·array[2]·>·0)179 »       »       »       »       »       if·(array.Length·==·3·&&·array[0]·>·0·&&·array[1]·>·0·&&·array[2]·>·0)
180 »       »       »       »       »       {180 »       »       »       »       »       {
181 »       »       »       »       »       »       this.Age.DateOfBirth·=·new·DateTime(array[0],·array[1],·array[2]);181 »       »       »       »       »       »       this.Age.DateOfBirth·=·new·DateTime(array[0],·array[1],·array[2]);
182 »       »       »       »       »       }182 »       »       »       »       »       }
183 »       »       »       »       »       this.Store.ActiveCosmicube·=·LegacySaveManager.LastCosmicube;183 »       »       »       »       »       this.Store.ActiveCosmicube·=·LegacySaveManager.LastCosmicube;
184 »       »       »       »       »       this.Store.SetLegacyPurchases();184 »       »       »       »       »       this.Store.MigrateLegacyPurchases();
185 »       »       »       »       »       if·(LegacySaveManager.StoreTabViewDatesFileExists())185 »       »       »       »       »       if·(LegacySaveManager.StoreTabViewDatesFileExists())
186 »       »       »       »       »       {186 »       »       »       »       »       {
187 »       »       »       »       »       »       foreach·(object·obj·in·Enum.GetValues(typeof(StoreTab)))187 »       »       »       »       »       »       foreach·(object·obj·in·Enum.GetValues(typeof(StoreTab)))
188 »       »       »       »       »       »       {188 »       »       »       »       »       »       {
189 »       »       »       »       »       »       »       StoreTab·storeTab·=·(StoreTab)obj;189 »       »       »       »       »       »       »       StoreTab·storeTab·=·(StoreTab)obj;
190 »       »       »       »       »       »       »       string·text;190 »       »       »       »       »       »       »       string·text;
191 »       »       »       »       »       »       »       if·(LegacySaveManager.TryGetStoreTabViewDate(storeTab,·out·text))191 »       »       »       »       »       »       »       if·(LegacySaveManager.TryGetStoreTabViewDate(storeTab,·out·text))
1.66 KB
Assembly-CSharp/Amongus/Data/Player/PlayerStoreData.cs
    
Offset 177, 48 lines modifiedOffset 177, 51 lines modified
177 »       »       »       case·StoreTab.Nameplates:177 »       »       »       case·StoreTab.Nameplates:
178 »       »       »       »       this.LastNameplatesViewDate·=·val;178 »       »       »       »       this.LastNameplatesViewDate·=·val;
179 »       »       »       »       return;179 »       »       »       »       return;
180 »       »       »       }180 »       »       »       }
181 »       »       »       Debug.LogError(string.Format("[{0}]·{1}.{2}·has·not·been·configured.",·"PlayerStoreData",·"StoreTab",·tab));181 »       »       »       Debug.LogError(string.Format("[{0}]·{1}.{2}·has·not·been·configured.",·"PlayerStoreData",·"StoreTab",·tab));
182 »       »       }182 »       »       }
183 183
184 »       »       public·void·SetLegacyPurchases()184 »       »       public·void·MigrateLegacyPurchases()
185 »       »       {185 »       »       {
186 »       »       »       foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS)186 »       »       »       foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS)
187 »       »       »       {187 »       »       »       {
188 »       »       »       »       this.TryAddLegacyUnlock(text);188 »       »       »       »       this.TryMigrateLegacyUnlock(text);
189 »       »       »       }189 »       »       »       }
190 »       »       }190 »       »       }
191 191
192 »       »       private·void·TryAddLegacyUnlock(string·key)192 »       »       private·void·TryMigrateLegacyUnlock(string·key)
193 »       »       {193 »       »       {
194 »       »       »       if·(LegacySaveManager.GetPurchase(key,·null))194 »       »       »       if·(LegacySaveManager.GetPurchase(key,·null))
195 »       »       »       {195 »       »       »       {
 196 »       »       »       »       this.AddLegacyPurchases(new·string[]·{·key·});
196 »       »       »       »       if·(string.IsNullOrEmpty(key)) 
197 »       »       »       »       { 
198 »       »       »       »       »       return; 
199 »       »       »       »       } 
200 »       »       »       »       if·(this.legacyPurchases.Contains(key)) 
201 »       »       »       »       { 
202 »       »       »       »       »       return; 
203 »       »       »       »       } 
204 »       »       »       »       this.legacyPurchases.Add(key); 
205 »       »       »       }197 »       »       »       }
206 »       »       }198 »       »       }
207 199
208 »       »       public·bool·HasLegacyPurchase(string·key)200 »       »       public·bool·HasLegacyPurchase(string·key)
209 »       »       {201 »       »       {
210 »       »       »       return·this.legacyPurchases.Contains(key);202 »       »       »       return·this.legacyPurchases.Contains(key);
211 »       »       }203 »       »       }
212 204
213 »       »       public·string[]·GetLegacyPurchases()205 »       »       public·string[]·GetLegacyPurchases()
214 »       »       {206 »       »       {
215 »       »       »       return·this.legacyPurchases.ToArray();207 »       »       »       return·this.legacyPurchases.ToArray();
216 »       »       }208 »       »       }
217 209
 210 »       »       public·void·AddLegacyPurchases(params·string[]·keys)
 211 »       »       {
 212 »       »       »       foreach·(string·text·in·keys)
 213 »       »       »       {
 214 »       »       »       »       if·(!string.IsNullOrEmpty(text)·&&·!this.legacyPurchases.Contains(text))
 215 »       »       »       »       {
 216 »       »       »       »       »       this.legacyPurchases.Add(text);
 217 »       »       »       »       }
 218 »       »       »       }
 219 »       »       }
 220
218 »       »       public·const·string·DEFAULT_ACTIVE_COSMICUBE·=·"";221 »       »       public·const·string·DEFAULT_ACTIVE_COSMICUBE·=·"";
219 222
220 »       »       public·static·readonly·DateTime·DEFAULT_LAST_VIEW_DATE·=·DateTime.MinValue;223 »       »       public·static·readonly·DateTime·DEFAULT_LAST_VIEW_DATE·=·DateTime.MinValue;
221 224
222 »       »       [JsonProperty("activeCosmicube")]225 »       »       [JsonProperty("activeCosmicube")]
223 »       »       private·string·activeCosmicube·=·"";226 »       »       private·string·activeCosmicube·=·"";
224 227
392 B
Assembly-CSharp/Amongus/GameOptions/BoolOptionNames.cs
    
Offset 12, 10 lines modifiedOffset 12, 11 lines modified
12 »       »       IsDefaults,12 »       »       IsDefaults,
13 »       »       UseFlashlight,13 »       »       UseFlashlight,
14 »       »       SeekerFinalVents,14 »       »       SeekerFinalVents,
15 »       »       SeekerFinalMap,15 »       »       SeekerFinalMap,
16 »       »       SeekerPings,16 »       »       SeekerPings,
17 »       »       ShowCrewmateNames,17 »       »       ShowCrewmateNames,
18 »       »       ShapeshifterLeaveSkin·=·1000,18 »       »       ShapeshifterLeaveSkin·=·1000,
19 »       »       ImpostorsCanSeeProtect·=·110019 »       »       ImpostorsCanSeeProtect·=·1100,
 20 »       »       NoisemakerImpostorAlert·=·1300
20 »       }21 »       }
21 }22 }
554 B
Assembly-CSharp/Amongus/GameOptions/FloatOptionNames.cs
    
Offset 19, 10 lines modifiedOffset 19, 16 lines modified
19 »       »       ShapeshifterCooldown·=·1000,19 »       »       ShapeshifterCooldown·=·1000,
20 »       »       ShapeshifterDuration,20 »       »       ShapeshifterDuration,
21 »       »       ProtectionDurationSeconds·=·1100,21 »       »       ProtectionDurationSeconds·=·1100,
22 »       »       GuardianAngelCooldown,22 »       »       GuardianAngelCooldown,
23 »       »       ScientistCooldown·=·1200,23 »       »       ScientistCooldown·=·1200,
24 »       »       ScientistBatteryCharge,24 »       »       ScientistBatteryCharge,
25 »       »       EngineerCooldown·=·1300,25 »       »       EngineerCooldown·=·1300,
26 »       »       EngineerInVentMaxTime26 »       »       EngineerInVentMaxTime,
 27 »       »       PhantomCooldown·=·1500,
 28 »       »       PhantomDuration,
 29 »       »       TrackerCooldown·=·1550,
 30 »       »       TrackerDuration,
 31 »       »       TrackerDelay,
 32 »       »       NoisemakerAlertDuration·=·1600
27 »       }33 »       }
28 }34 }
508 B
Assembly-CSharp/Amongus/GameOptions/GameKeywords.cs
Ordering differences only
    
Offset 1, 15 lines modifiedOffset 1, 15 lines modified
1 using·System;1 using·System;
2 using·Newtonsoft.Json;2 using·Newtonsoft.Json;
3 using·Newtonsoft.Json.Converters;3 using·Newtonsoft.Json.Converters;
4 4
5 namespace·AmongUs.GameOptions5 namespace·AmongUs.GameOptions
6 {6 {
7 »       [JsonConverter(typeof(StringEnumConverter))] 
8 »       [Flags]7 »       [Flags]
 8 »       [JsonConverter(typeof(StringEnumConverter))]
9 »       public·enum·GameKeywords·:·uint9 »       public·enum·GameKeywords·:·uint
10 »       {10 »       {
11 »       »       All·=·0U,11 »       »       All·=·0U,
12 »       »       English·=·256U,12 »       »       English·=·256U,
13 »       »       SpanishLA·=·2U,13 »       »       SpanishLA·=·2U,
14 »       »       Brazilian·=·2048U,14 »       »       Brazilian·=·2048U,
15 »       »       Portuguese·=·16U,15 »       »       Portuguese·=·16U,
1.47 KB
Assembly-CSharp/Amongus/GameOptions/GameOptionsData.cs
    
Offset 6, 14 lines modifiedOffset 6, 22 lines modified
6 {6 {
7 »       public·class·GameOptionsData·:·IGameOptions7 »       public·class·GameOptionsData·:·IGameOptions
8 »       {8 »       {
9 »       »       public·byte·Version·{·get;·private·set;·}·=·6;9 »       »       public·byte·Version·{·get;·private·set;·}·=·6;
10 10
11 »       »       public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal;11 »       »       public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal;
12 12
 13 »       »       public·SpecialGameModes·SpecialMode
 14 »       »       {
 15 »       »       »       get
 16 »       »       »       {
 17 »       »       »       »       return·SpecialGameModes.None;
 18 »       »       »       }
 19 »       »       }
 20
13 »       »       public·GameModes·AprilFoolsOnMode21 »       »       public·GameModes·AprilFoolsOnMode
14 »       »       {22 »       »       {
15 »       »       »       get23 »       »       »       get
16 »       »       »       {24 »       »       »       {
17 »       »       »       »       return·GameModes.NormalFools;25 »       »       »       »       return·GameModes.NormalFools;
18 »       »       »       }26 »       »       »       }
19 »       »       }27 »       »       }
Offset 22, 14 lines modifiedOffset 30, 16 lines modified
22 »       »       {30 »       »       {
23 »       »       »       get31 »       »       »       get
24 »       »       »       {32 »       »       »       {
25 »       »       »       »       return·GameModes.Normal;33 »       »       »       »       return·GameModes.Normal;
26 »       »       »       }34 »       »       »       }
27 »       »       }35 »       »       }
28 36
 37 »       »       public·RulesPresets·RulesPreset·{·get;·set;·}
 38
29 »       »       public·int·MaxPlayers·{·get;·private·set;·}·=·10;39 »       »       public·int·MaxPlayers·{·get;·private·set;·}·=·10;
30 40
31 »       »       public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English;41 »       »       public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English;
32 42
33 »       »       public·byte·MapId·{·get;·private·set;·}43 »       »       public·byte·MapId·{·get;·private·set;·}
34 44
35 »       »       public·IRoleOptionsCollection·RoleOptions45 »       »       public·IRoleOptionsCollection·RoleOptions
Offset 184, 14 lines modifiedOffset 194, 18 lines modified
184 »       »       »       this.roleOptions.ScientistBatteryCharge·=·5f;194 »       »       »       this.roleOptions.ScientistBatteryCharge·=·5f;
185 »       »       »       this.roleOptions.GuardianAngelCooldown·=·60f;195 »       »       »       this.roleOptions.GuardianAngelCooldown·=·60f;
186 »       »       »       this.roleOptions.ProtectionDurationSeconds·=·10f;196 »       »       »       this.roleOptions.ProtectionDurationSeconds·=·10f;
187 »       »       »       this.roleOptions.EngineerCooldown·=·30f;197 »       »       »       this.roleOptions.EngineerCooldown·=·30f;
188 »       »       »       this.roleOptions.EngineerInVentMaxTime·=·15f;198 »       »       »       this.roleOptions.EngineerInVentMaxTime·=·15f;
189 »       »       }199 »       »       }
190 200
 201 »       »       public·void·SetRecommendations(int·numPlayers,·bool·isOnline,·RulesPresets·rulesPresets)
 202 »       »       {
 203 »       »       }
 204
191 »       »       public·bool·Validate(int·numPlayers)205 »       »       public·bool·Validate(int·numPlayers)
192 »       »       {206 »       »       {
193 »       »       »       bool·flag·=·false;207 »       »       »       bool·flag·=·false;
194 »       »       »       if·(this.NumCommonTasks·+·this.NumLongTasks·+·this.NumShortTasks·==·0)208 »       »       »       if·(this.NumCommonTasks·+·this.NumLongTasks·+·this.NumShortTasks·==·0)
195 »       »       »       {209 »       »       »       {
196 »       »       »       »       this.NumShortTasks·=·1;210 »       »       »       »       this.NumShortTasks·=·1;
197 »       »       »       »       flag·=·true;211 »       »       »       »       flag·=·true;
2.96 KB
Assembly-CSharp/Amongus/GameOptions/GameOptionsFactory.cs
    
Offset 126, 50 lines modifiedOffset 126, 70 lines modified
126 »       »       »       »       this.logger.WriteError(string.Format("Could·not·parse·options·data·for·game·mode·{0}",·gameModes));126 »       »       »       »       this.logger.WriteError(string.Format("Could·not·parse·options·data·for·game·mode·{0}",·gameModes));
127 »       »       »       »       return·null;127 »       »       »       »       return·null;
128 »       »       »       }128 »       »       »       }
129 »       »       }129 »       »       }
130 130
131 »       »       private·void·NormalModeToWriter(MessageWriter·writer,·IGameOptions·optionsData)131 »       »       private·void·NormalModeToWriter(MessageWriter·writer,·IGameOptions·optionsData)
132 »       »       {132 »       »       {
133 »       »       »       if·(optionsData.Version·==·7)133 »       »       »       byte·version·=·optionsData.Version;
 134 »       »       »       if·(version·==·7)
134 »       »       »       {135 »       »       »       {
135 »       »       »       »       NormalGameOptionsV07.Serialize(writer,·optionsData·as·NormalGameOptionsV07);136 »       »       »       »       NormalGameOptionsV07.Serialize(writer,·optionsData·as·NormalGameOptionsV07);
136 »       »       »       »       return;137 »       »       »       »       return;
137 »       »       »       }138 »       »       »       }
 139 »       »       »       if·(version·!=·8)
 140 »       »       »       {
138 »       »       »       this.logger.WriteError(string.Format("Could·not·serialize·normal·options·data·for·version·{0}",·optionsData.Version));141 »       »       »       »       this.logger.WriteError(string.Format("Could·not·serialize·normal·options·data·for·version·{0}",·optionsData.Version));
 142 »       »       »       »       return;
 143 »       »       »       }
 144 »       »       »       NormalGameOptionsV08.Serialize(writer,·optionsData·as·NormalGameOptionsV08);
139 »       »       }145 »       »       }
140 146
141 »       »       private·void·HideNSeekModeToWriter(MessageWriter·writer,·IGameOptions·optionsData)147 »       »       private·void·HideNSeekModeToWriter(MessageWriter·writer,·IGameOptions·optionsData)
142 »       »       {148 »       »       {
143 »       »       »       if·(optionsData.Version·==·7)149 »       »       »       byte·version·=·optionsData.Version;
 150 »       »       »       if·(version·==·7)
144 »       »       »       {151 »       »       »       {
145 »       »       »       »       HideNSeekGameOptionsV07.Serialize(writer,·optionsData·as·HideNSeekGameOptionsV07);152 »       »       »       »       HideNSeekGameOptionsV07.Serialize(writer,·optionsData·as·HideNSeekGameOptionsV07);
146 »       »       »       »       return;153 »       »       »       »       return;
147 »       »       »       }154 »       »       »       }
 155 »       »       »       if·(version·!=·8)
 156 »       »       »       {
148 »       »       »       this.logger.WriteError(string.Format("Could·not·serialize·hidenseek·options·data·for·version·{0}",·optionsData.Version));157 »       »       »       »       this.logger.WriteError(string.Format("Could·not·serialize·hidenseek·options·data·for·version·{0}",·optionsData.Version));
 158 »       »       »       »       return;
 159 »       »       »       }
 160 »       »       »       HideNSeekGameOptionsV08.Serialize(writer,·optionsData·as·HideNSeekGameOptionsV08);
149 »       »       }161 »       »       }
150 162
151 »       »       private·IGameOptions·NormalModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode)163 »       »       private·IGameOptions·NormalModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode)
152 »       »       {164 »       »       {
153 »       »       »       if·(version·==·7)165 »       »       »       if·(version·==·7)
154 »       »       »       {166 »       »       »       {
155 »       »       »       »       return·NormalGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger);167 »       »       »       »       return·NormalGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger);
156 »       »       »       }168 »       »       »       }
 169 »       »       »       if·(version·!=·8)
 170 »       »       »       {
157 »       »       »       this.logger.WriteError(string.Format("Could·not·parse·normal·game·options·for·version·{0}",·version));171 »       »       »       »       this.logger.WriteError(string.Format("Could·not·parse·normal·game·options·for·version·{0}",·version));
158 »       »       »       return·null;172 »       »       »       »       return·null;
 173 »       »       »       }
 174 »       »       »       return·NormalGameOptionsV08.Deserialize(reader,·isAprilFoolsMode,·this.logger);
159 »       »       }175 »       »       }
160 176
161 »       »       private·IGameOptions·HideNSeekModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode)177 »       »       private·IGameOptions·HideNSeekModeFromBytes(MessageReader·reader,·byte·version,·bool·isAprilFoolsMode)
162 »       »       {178 »       »       {
163 »       »       »       if·(version·==·7)179 »       »       »       if·(version·==·7)
164 »       »       »       {180 »       »       »       {
165 »       »       »       »       return·HideNSeekGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger);181 »       »       »       »       return·HideNSeekGameOptionsV07.Deserialize(reader,·isAprilFoolsMode,·this.logger);
166 »       »       »       }182 »       »       »       }
 183 »       »       »       if·(version·!=·8)
 184 »       »       »       {
167 »       »       »       this.logger.WriteError(string.Format("Could·not·parse·hidenseek·game·options·for·version·{0}",·version));185 »       »       »       »       this.logger.WriteError(string.Format("Could·not·parse·hidenseek·game·options·for·version·{0}",·version));
168 »       »       »       return·null;186 »       »       »       »       return·null;
 187 »       »       »       }
 188 »       »       »       return·HideNSeekGameOptionsV08.Deserialize(reader,·isAprilFoolsMode,·this.logger);
169 »       »       }189 »       »       }
170 190
171 »       »       private·const·byte·ModularOptionsDataVersion·=·7;191 »       »       private·const·byte·ModularOptionsDataVersion·=·7;
172 192
173 »       »       private·readonly·ILogger·logger;193 »       »       private·readonly·ILogger·logger;
174 »       }194 »       }
175 }195 }
1.31 KB
Assembly-CSharp/Amongus/GameOptions/HideNSeekGameOptionsV07.cs
    
Offset 11, 14 lines modifiedOffset 11, 22 lines modified
11 »       »       »       {11 »       »       »       {
12 »       »       »       »       return·7;12 »       »       »       »       return·7;
13 »       »       »       }13 »       »       »       }
14 »       »       }14 »       »       }
15 15
16 »       »       public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.HideNSeek;16 »       »       public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.HideNSeek;
17 17
 18 »       »       public·SpecialGameModes·SpecialMode
 19 »       »       {
 20 »       »       »       get
 21 »       »       »       {
 22 »       »       »       »       return·SpecialGameModes.None;
 23 »       »       »       }
 24 »       »       }
 25
18 »       »       public·GameModes·AprilFoolsOnMode26 »       »       public·GameModes·AprilFoolsOnMode
19 »       »       {27 »       »       {
20 »       »       »       get28 »       »       »       get
21 »       »       »       {29 »       »       »       {
22 »       »       »       »       return·GameModes.SeekFools;30 »       »       »       »       return·GameModes.SeekFools;
23 »       »       »       }31 »       »       »       }
24 »       »       }32 »       »       }
Offset 27, 14 lines modifiedOffset 35, 16 lines modified
27 »       »       {35 »       »       {
28 »       »       »       get36 »       »       »       get
29 »       »       »       {37 »       »       »       {
30 »       »       »       »       return·GameModes.HideNSeek;38 »       »       »       »       return·GameModes.HideNSeek;
31 »       »       »       }39 »       »       »       }
32 »       »       }40 »       »       }
33 41
 42 »       »       public·RulesPresets·RulesPreset·{·get;·set;·}
 43
34 »       »       public·int·MaxPlayers·{·get;·private·set;·}·=·15;44 »       »       public·int·MaxPlayers·{·get;·private·set;·}·=·15;
35 45
36 »       »       public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English;46 »       »       public·GameKeywords·Keywords·{·get;·private·set;·}·=·GameKeywords.English;
37 47
38 »       »       public·byte·MapId·{·get;·private·set;·}48 »       »       public·byte·MapId·{·get;·private·set;·}
39 49
40 »       »       public·bool·IsDefaults·{·get;·private·set;·}·=·true;50 »       »       public·bool·IsDefaults·{·get;·private·set;·}·=·true;
Offset 154, 14 lines modifiedOffset 164, 18 lines modified
154 »       »       »       this.SeekerFinalSpeed·=·1.2f;164 »       »       »       this.SeekerFinalSpeed·=·1.2f;
155 »       »       »       this.SeekerPings·=·true;165 »       »       »       this.SeekerPings·=·true;
156 »       »       »       this.ShowCrewmateNames·=·false;166 »       »       »       this.ShowCrewmateNames·=·false;
157 »       »       »       this.MaxPingTime·=·6f;167 »       »       »       this.MaxPingTime·=·6f;
158 »       »       »       this.IsDefaults·=·true;168 »       »       »       this.IsDefaults·=·true;
159 »       »       }169 »       »       }
160 170
 171 »       »       public·void·SetRecommendations(int·numPlayers,·bool·isOnline,·RulesPresets·rulesPresets)
 172 »       »       {
 173 »       »       }
 174
161 »       »       public·void·SetByte(ByteOptionNames·optionName,·byte·value)175 »       »       public·void·SetByte(ByteOptionNames·optionName,·byte·value)
162 »       »       {176 »       »       {
163 »       »       »       if·(optionName·==·ByteOptionNames.MapId)177 »       »       »       if·(optionName·==·ByteOptionNames.MapId)
164 »       »       »       {178 »       »       »       {
165 »       »       »       »       this.MapId·=·value;179 »       »       »       »       this.MapId·=·value;
166 »       »       »       »       return;180 »       »       »       »       return;
167 »       »       »       }181 »       »       »       }
1.03 KB
Assembly-CSharp/Amongus/GameOptions/IGameOptions.cs
    
Offset 4, 18 lines modifiedOffset 4, 22 lines modified
4 {4 {
5 »       public·interface·IGameOptions5 »       public·interface·IGameOptions
6 »       {6 »       {
7 »       »       byte·Version·{·get;·}7 »       »       byte·Version·{·get;·}
8 8
9 »       »       GameModes·GameMode·{·get;·}9 »       »       GameModes·GameMode·{·get;·}
10 10
 11 »       »       SpecialGameModes·SpecialMode·{·get;·}
 12
11 »       »       GameModes·AprilFoolsOnMode·{·get;·}13 »       »       GameModes·AprilFoolsOnMode·{·get;·}
12 14
13 »       »       GameModes·AprilFoolsOffMode·{·get;·}15 »       »       GameModes·AprilFoolsOffMode·{·get;·}
14 16
 17 »       »       RulesPresets·RulesPreset·{·get;·}
 18
15 »       »       int·MaxPlayers·{·get;·}19 »       »       int·MaxPlayers·{·get;·}
16 20
17 »       »       GameKeywords·Keywords·{·get;·}21 »       »       GameKeywords·Keywords·{·get;·}
18 22
19 »       »       byte·MapId·{·get;·}23 »       »       byte·MapId·{·get;·}
20 24
21 »       »       int·NumImpostors·{·get;·}25 »       »       int·NumImpostors·{·get;·}
Offset 26, 14 lines modifiedOffset 30, 16 lines modified
26 30
27 »       »       IRoleOptionsCollection·RoleOptions·{·get;·}31 »       »       IRoleOptionsCollection·RoleOptions·{·get;·}
28 32
29 »       »       bool·AreInvalid(int·maxExpectedPlayers);33 »       »       bool·AreInvalid(int·maxExpectedPlayers);
30 34
31 »       »       void·SetRecommendations(int·numPlayers,·bool·isOnlineGame);35 »       »       void·SetRecommendations(int·numPlayers,·bool·isOnlineGame);
32 36
 37 »       »       void·SetRecommendations(int·numPlayers,·bool·isOnlineGame,·RulesPresets·rulesPreset);
 38
33 »       »       void·SetByte(ByteOptionNames·optionName,·byte·value);39 »       »       void·SetByte(ByteOptionNames·optionName,·byte·value);
34 40
35 »       »       void·SetFloat(FloatOptionNames·optionName,·float·value);41 »       »       void·SetFloat(FloatOptionNames·optionName,·float·value);
36 42
37 »       »       void·SetBool(BoolOptionNames·optionName,·bool·value);43 »       »       void·SetBool(BoolOptionNames·optionName,·bool·value);
38 44
39 »       »       void·SetInt(Int32OptionNames·optionName,·int·value);45 »       »       void·SetInt(Int32OptionNames·optionName,·int·value);
354 B
Assembly-CSharp/Amongus/GameOptions/Int32OptionNames.cs
    
Offset 16, 10 lines modifiedOffset 16, 11 lines modified
16 »       »       MaxPlayers,16 »       »       MaxPlayers,
17 »       »       NumCommonTasks,17 »       »       NumCommonTasks,
18 »       »       NumShortTasks,18 »       »       NumShortTasks,
19 »       »       NumLongTasks,19 »       »       NumLongTasks,
20 »       »       TaskBarMode,20 »       »       TaskBarMode,
21 »       »       CrewmatesRemainingForVitals·=·100,21 »       »       CrewmatesRemainingForVitals·=·100,
22 »       »       CrewmateVentUses,22 »       »       CrewmateVentUses,
23 »       »       ImpostorPlayerID23 »       »       ImpostorPlayerID,
 24 »       »       RulePreset·=·200
24 »       }25 »       }
25 }26 }
1.42 KB
Assembly-CSharp/Amongus/GameOptions/NormalGameOptionsV07.cs
    
Offset 11, 14 lines modifiedOffset 11, 22 lines modified
11 »       »       »       {11 »       »       »       {
12 »       »       »       »       return·7;12 »       »       »       »       return·7;
13 »       »       »       }13 »       »       »       }
14 »       »       }14 »       »       }
15 15
16 »       »       public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal;16 »       »       public·GameModes·GameMode·{·get;·private·set;·}·=·GameModes.Normal;
17 17
 18 »       »       public·SpecialGameModes·SpecialMode
 19 »       »       {
 20 »       »       »       get
 21 »       »       »       {
 22 »       »       »       »       return·SpecialGameModes.None;
 23 »       »       »       }
 24 »       »       }
 25
18 »       »       public·GameModes·AprilFoolsOnMode26 »       »       public·GameModes·AprilFoolsOnMode
19 »       »       {27 »       »       {
20 »       »       »       get28 »       »       »       get
21 »       »       »       {29 »       »       »       {
22 »       »       »       »       return·GameModes.NormalFools;30 »       »       »       »       return·GameModes.NormalFools;
23 »       »       »       }31 »       »       »       }
24 »       »       }32 »       »       }
Offset 27, 14 lines modifiedOffset 35, 16 lines modified
27 »       »       {35 »       »       {
28 »       »       »       get36 »       »       »       get
29 »       »       »       {37 »       »       »       {
30 »       »       »       »       return·GameModes.Normal;38 »       »       »       »       return·GameModes.Normal;
31 »       »       »       }39 »       »       »       }
32 »       »       }40 »       »       }
33 41
 42 »       »       public·RulesPresets·RulesPreset·{·get;·set;·}
 43
34 »       »       public·int·MaxPlayers·{·get;·set;·}·=·10;44 »       »       public·int·MaxPlayers·{·get;·set;·}·=·10;
35 45
36 »       »       public·GameKeywords·Keywords·{·get;·set;·}·=·GameKeywords.English;46 »       »       public·GameKeywords·Keywords·{·get;·set;·}·=·GameKeywords.English;
37 47
38 »       »       public·byte·MapId·{·get;·set;·}48 »       »       public·byte·MapId·{·get;·set;·}
39 49
40 »       »       public·bool·IsDefaults·{·get;·set;·}·=·true;50 »       »       public·bool·IsDefaults·{·get;·set;·}·=·true;
Offset 163, 14 lines modifiedOffset 173, 18 lines modified
163 »       »       »       this.roleOptions.SetRoleRate(RoleTypes.Engineer,·0,·0);173 »       »       »       this.roleOptions.SetRoleRate(RoleTypes.Engineer,·0,·0);
164 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.Shapeshifter);174 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.Shapeshifter);
165 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.Scientist);175 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.Scientist);
166 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.GuardianAngel);176 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.GuardianAngel);
167 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.Engineer);177 »       »       »       this.roleOptions.SetRoleRecommended(RoleTypes.Engineer);
168 »       »       }178 »       »       }
169 179
 180 »       »       public·void·SetRecommendations(int·numPlayers,·bool·isOnline,·RulesPresets·rulesPresets)
 181 »       »       {
 182 »       »       }
 183
170 »       »       public·void·SetByte(ByteOptionNames·optionName,·byte·value)184 »       »       public·void·SetByte(ByteOptionNames·optionName,·byte·value)
171 »       »       {185 »       »       {
172 »       »       »       if·(optionName·==·ByteOptionNames.MapId)186 »       »       »       if·(optionName·==·ByteOptionNames.MapId)
173 »       »       »       {187 »       »       »       {
174 »       »       »       »       this.MapId·=·value;188 »       »       »       »       this.MapId·=·value;
175 »       »       »       »       return;189 »       »       »       »       return;
176 »       »       »       }190 »       »       »       }
314 B
Assembly-CSharp/Amongus/GameOptions/RoleTypes.cs
    
Offset 7, 10 lines modifiedOffset 7, 13 lines modified
7 »       »       Crewmate,7 »       »       Crewmate,
8 »       »       Impostor,8 »       »       Impostor,
9 »       »       Scientist,9 »       »       Scientist,
10 »       »       Engineer,10 »       »       Engineer,
11 »       »       GuardianAngel,11 »       »       GuardianAngel,
12 »       »       Shapeshifter,12 »       »       Shapeshifter,
13 »       »       CrewmateGhost,13 »       »       CrewmateGhost,
14 »       »       ImpostorGhost14 »       »       ImpostorGhost,
 15 »       »       Noisemaker,
 16 »       »       Phantom,
 17 »       »       Tracker
15 »       }18 »       }
16 }19 }
531 B
Assembly-CSharp/Amongus/QuickChat/AbstractQuickChatMenuPhrasesPageButton.cs
Ordering differences only
    
Offset 195, 16 lines modifiedOffset 195, 16 lines modified
195 »       »       [SerializeField]195 »       »       [SerializeField]
196 »       »       [Space(10f)]196 »       »       [Space(10f)]
197 »       »       private·TextMeshPro·text;197 »       »       private·TextMeshPro·text;
198 198
199 »       »       [SerializeField]199 »       »       [SerializeField]
200 »       »       private·RectTransform·textRect;200 »       »       private·RectTransform·textRect;
201 201
202 »       »       [Space(10f)] 
203 »       »       [SerializeField]202 »       »       [SerializeField]
 203 »       »       [Space(10f)]
204 »       »       private·SpriteRenderer·arrow;204 »       »       private·SpriteRenderer·arrow;
205 205
206 »       »       [SerializeField]206 »       »       [SerializeField]
207 »       »       private·SpriteRenderer[]·backgroundSprites;207 »       »       private·SpriteRenderer[]·backgroundSprites;
208 208
209 »       »       private·QuickChatPhrase·phrase;209 »       »       private·QuickChatPhrase·phrase;
210 210
1.63 KB
Assembly-CSharp/Amongus/QuickChat/QuickChatContext.cs
    
Offset 159, 15 lines modifiedOffset 159, 15 lines modified
159 »       »       }159 »       »       }
160 160
161 »       »       private·void·UpdateWithCurrentMap()161 »       »       private·void·UpdateWithCurrentMap()
162 »       »       {162 »       »       {
163 »       »       »       ShipStatus·instance·=·ShipStatus.Instance;163 »       »       »       ShipStatus·instance·=·ShipStatus.Instance;
164 »       »       »       this.phase·=·QuickChatContextPhase.Game;164 »       »       »       this.phase·=·QuickChatContextPhase.Game;
165 »       »       »       this.map·=·this.GetCurrentMapID(instance);165 »       »       »       this.map·=·this.GetCurrentMapID(instance);
166 »       »       »       this.meetingCount·=·TempData.MeetingCount;166 »       »       »       this.meetingCount·=·GameData.MeetingCount;
167 »       »       »       this.locations·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Select<PlainShipRoom,·StringNames>(instance.AllRooms,·(PlainShipRoom·room)·=>·DestroyableSingleton<TranslationController>.Instance.GetSystemName(room.RoomId))));167 »       »       »       this.locations·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Select<PlainShipRoom,·StringNames>(instance.AllRooms,·(PlainShipRoom·room)·=>·DestroyableSingleton<TranslationController>.Instance.GetSystemName(room.RoomId))));
168 »       »       »       this.roles·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Concat<StringNames>(Enumerable.Select<RoleBehaviour,·StringNames>(Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·!Enumerable.Contains<RoleTypes>(QuickChatContext.ROLES_TO_IGNORE,·role.Role)),·(RoleBehaviour·role)·=>·role.StringName),·new·StringNames[]·{·StringNames.Ghost·})));168 »       »       »       this.roles·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Concat<StringNames>(Enumerable.Select<RoleBehaviour,·StringNames>(Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·!Enumerable.Contains<RoleTypes>(QuickChatContext.ROLES_TO_IGNORE,·role.Role)),·(RoleBehaviour·role)·=>·role.StringName),·new·StringNames[]·{·StringNames.Ghost·})));
169 »       »       »       this.systems·=·instance.SystemNames;169 »       »       »       this.systems·=·instance.SystemNames;
170 »       »       »       this.tasks·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Where<StringNames>(Enumerable.Concat<StringNames>(instance.ExtraTaskNames,·Enumerable.Select<PlayerTask,·StringNames>(instance.GetAllTasks(),·(PlayerTask·task)·=>·DestroyableSingleton<TranslationController>.Instance.GetTaskName(task.TaskType))),·(StringNames·stringName)·=>·!Enumerable.Contains<StringNames>(QuickChatContext.TASKS_TO_IGNORE,·stringName))));170 »       »       »       this.tasks·=·Enumerable.ToArray<StringNames>(Enumerable.Distinct<StringNames>(Enumerable.Where<StringNames>(Enumerable.Concat<StringNames>(instance.ExtraTaskNames,·Enumerable.Select<PlayerTask,·StringNames>(instance.GetAllTasks(),·(PlayerTask·task)·=>·DestroyableSingleton<TranslationController>.Instance.GetTaskName(task.TaskType))),·(StringNames·stringName)·=>·!Enumerable.Contains<StringNames>(QuickChatContext.TASKS_TO_IGNORE,·stringName))));
171 »       »       }171 »       »       }
172 172
173 »       »       private·MapNames·GetCurrentMapID(ShipStatus·ship)173 »       »       private·MapNames·GetCurrentMapID(ShipStatus·ship)
807 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenu.cs
Ordering differences only
    
Offset 418, 30 lines modifiedOffset 418, 30 lines modified
418 418
419 »       »       [SerializeField]419 »       »       [SerializeField]
420 »       »       private·Transform·container;420 »       »       private·Transform·container;
421 421
422 »       »       [SerializeField]422 »       »       [SerializeField]
423 »       »       private·SpriteRenderer·frame;423 »       »       private·SpriteRenderer·frame;
424 424
425 »       »       [SerializeField] 
426 »       »       [Space(10f)]425 »       »       [Space(10f)]
 426 »       »       [SerializeField]
427 »       »       private·Transform·topContentBlocker;427 »       »       private·Transform·topContentBlocker;
428 428
429 »       »       [SerializeField]429 »       »       [SerializeField]
430 »       »       private·Transform·bottomContentBlocker;430 »       »       private·Transform·bottomContentBlocker;
431 431
432 »       »       [Space(10f)]432 »       »       [Space(10f)]
433 »       »       [SerializeField]433 »       »       [SerializeField]
434 »       »       private·PassiveButton·closeButton;434 »       »       private·PassiveButton·closeButton;
435 435
436 »       »       [SerializeField]436 »       »       [SerializeField]
437 »       »       private·GameObject·closeButtonGlyph;437 »       »       private·GameObject·closeButtonGlyph;
438 438
439 »       »       [Header("Animations")] 
440 »       »       [SerializeField]439 »       »       [SerializeField]
 440 »       »       [Header("Animations")]
441 »       »       private·AnimationCurve·animationIn;441 »       »       private·AnimationCurve·animationIn;
442 442
443 »       »       [SerializeField]443 »       »       [SerializeField]
444 »       »       private·AnimationCurve·animationOut;444 »       »       private·AnimationCurve·animationOut;
445 445
446 »       »       [Header("Pages")]446 »       »       [Header("Pages")]
447 »       »       [SerializeField]447 »       »       [SerializeField]
766 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuHeader.cs
Ordering differences only
    
Offset 179, 27 lines modifiedOffset 179, 27 lines modified
179 179
180 »       »       [SerializeField]180 »       »       [SerializeField]
181 »       »       private·Transform·textMask;181 »       »       private·Transform·textMask;
182 182
183 »       »       [SerializeField]183 »       »       [SerializeField]
184 »       »       private·Transform·textGradient;184 »       »       private·Transform·textGradient;
185 185
186 »       »       [Space(10f)] 
187 »       »       [SerializeField]186 »       »       [SerializeField]
 187 »       »       [Space(10f)]
188 »       »       private·PassiveButton·backButton;188 »       »       private·PassiveButton·backButton;
189 189
190 »       »       [SerializeField]190 »       »       [SerializeField]
191 »       »       private·BoxCollider2D·backButtonCollider;191 »       »       private·BoxCollider2D·backButtonCollider;
192 192
193 »       »       [SerializeField] 
194 »       »       [Space(10f)]193 »       »       [Space(10f)]
 194 »       »       [SerializeField]
195 »       »       private·Transform·divider;195 »       »       private·Transform·divider;
196 196
197 »       »       [SerializeField] 
198 »       »       [Space(10f)]197 »       »       [Space(10f)]
 198 »       »       [SerializeField]
199 »       »       private·GameObject·favoriteBox;199 »       »       private·GameObject·favoriteBox;
200 200
201 »       »       [SerializeField]201 »       »       [SerializeField]
202 »       »       private·GameObject·favoriteBoxContainer;202 »       »       private·GameObject·favoriteBoxContainer;
203 203
204 »       »       [SerializeField]204 »       »       [SerializeField]
205 »       »       private·GameObject·favoriteBoxGlyph;205 »       »       private·GameObject·favoriteBoxGlyph;
567 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuLandingPage.cs
Ordering differences only
    
Offset 175, 16 lines modifiedOffset 175, 16 lines modified
175 175
176 »       »       [SerializeField]176 »       »       [SerializeField]
177 »       »       private·QuickChatMenuLandingPageButton·remarksButton;177 »       »       private·QuickChatMenuLandingPageButton·remarksButton;
178 178
179 »       »       [SerializeField]179 »       »       [SerializeField]
180 »       »       private·Transform·contentBlocker;180 »       »       private·Transform·contentBlocker;
181 181
182 »       »       [Header("List")] 
183 »       »       [SerializeField]182 »       »       [SerializeField]
 183 »       »       [Header("List")]
184 »       »       private·Transform·listContainer;184 »       »       private·Transform·listContainer;
185 185
186 »       »       [SerializeField]186 »       »       [SerializeField]
187 »       »       private·QuickChatMenuScroller·scroller;187 »       »       private·QuickChatMenuScroller·scroller;
188 188
189 »       »       [SerializeField]189 »       »       [SerializeField]
190 »       »       private·QuickChatMenuLandingPageButton·buttonTemplate;190 »       »       private·QuickChatMenuLandingPageButton·buttonTemplate;
526 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuLandingPageButton.cs
Ordering differences only
    
Offset 132, 16 lines modifiedOffset 132, 16 lines modified
132 132
133 »       »       [SerializeField]133 »       »       [SerializeField]
134 »       »       private·RectTransform·textRect;134 »       »       private·RectTransform·textRect;
135 135
136 »       »       [SerializeField]136 »       »       [SerializeField]
137 »       »       private·TextTranslatorTMP·translator;137 »       »       private·TextTranslatorTMP·translator;
138 138
139 »       »       [SerializeField] 
140 »       »       [Space(10f)]139 »       »       [Space(10f)]
 140 »       »       [SerializeField]
141 »       »       private·SpriteRenderer[]·backgroundSprites;141 »       »       private·SpriteRenderer[]·backgroundSprites;
142 142
143 »       »       [SerializeField]143 »       »       [SerializeField]
144 »       »       private·SpriteRenderer[]·shineSprites;144 »       »       private·SpriteRenderer[]·shineSprites;
145 145
146 »       »       private·new·QuickChatTag·tag;146 »       »       private·new·QuickChatTag·tag;
147 »       }147 »       }
834 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuPhrasesPage.cs
Ordering differences only
    
Offset 181, 20 lines modifiedOffset 181, 20 lines modified
181 181
182 »       »       private·const·float·BOTTOM_PADDING·=·0.1f;182 »       »       private·const·float·BOTTOM_PADDING·=·0.1f;
183 183
184 »       »       private·static·readonly·Color32·TEXT_COLOR_ENABLED·=·Color.white;184 »       »       private·static·readonly·Color32·TEXT_COLOR_ENABLED·=·Color.white;
185 185
186 »       »       private·static·readonly·Color32·TEXT_COLOR_DISABLED·=·new·Color32(123,·123,·123,·byte.MaxValue);186 »       »       private·static·readonly·Color32·TEXT_COLOR_DISABLED·=·new·Color32(123,·123,·123,·byte.MaxValue);
187 187
188 »       »       [Header("UI")] 
189 »       »       [SerializeField]188 »       »       [SerializeField]
 189 »       »       [Header("UI")]
190 »       »       private·QuickChatMenuScroller·scroller;190 »       »       private·QuickChatMenuScroller·scroller;
191 191
192 »       »       [Header("Button·Templates")] 
193 »       »       [SerializeField]192 »       »       [SerializeField]
 193 »       »       [Header("Button·Templates")]
194 »       »       private·QuickChatMenuPhrasesPagePhraseButton·phraseButtonTemplate;194 »       »       private·QuickChatMenuPhrasesPagePhraseButton·phraseButtonTemplate;
195 195
196 »       »       [SerializeField]196 »       »       [SerializeField]
197 »       »       private·QuickChatMenuPhrasesPageCrewmateButton·crewmateButtonTemplate;197 »       »       private·QuickChatMenuPhrasesPageCrewmateButton·crewmateButtonTemplate;
198 198
199 »       »       [SerializeField]199 »       »       [SerializeField]
200 »       »       private·Material·defaultButtonTextMaterial;200 »       »       private·Material·defaultButtonTextMaterial;
1.33 KB
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuPhrasesPageCrewmateButton.cs
    
Offset 34, 15 lines modifiedOffset 34, 15 lines modified
34 »       »       »       base.TextRect.sizeDelta·=·base.Collider.size;34 »       »       »       base.TextRect.sizeDelta·=·base.Collider.size;
35 »       »       »       Vector3·localPosition·=·base.TextRect.localPosition;35 »       »       »       Vector3·localPosition·=·base.TextRect.localPosition;
36 »       »       »       localPosition.x·=·base.Collider.offset.x;36 »       »       »       localPosition.x·=·base.Collider.offset.x;
37 »       »       »       localPosition.y·=·base.Collider.offset.y;37 »       »       »       localPosition.y·=·base.Collider.offset.y;
38 »       »       »       base.TextRect.localPosition·=·localPosition;38 »       »       »       base.TextRect.localPosition·=·localPosition;
39 »       »       »       this.playerMask.material·=·new·Material(this.playerMask.material);39 »       »       »       this.playerMask.material·=·new·Material(this.playerMask.material);
40 »       »       »       this.playerMask.material.SetInt(PlayerMaterial.MaskLayer,·base.MaskLayer);40 »       »       »       this.playerMask.material.SetInt(PlayerMaterial.MaskLayer,·base.MaskLayer);
41 »       »       »       GameData.PlayerInfo·data·=·Enumerable.First<PlayerControl>(Enumerable.Where<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.PlayerId·==·base.Phrase.PlayerId)).Data;41 »       »       »       NetworkedPlayerInfo·data·=·Enumerable.First<PlayerControl>(Enumerable.Where<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.PlayerId·==·base.Phrase.PlayerId)).Data;
42 »       »       »       this.player.UpdateFromEitherPlayerDataOrCache(data,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null);42 »       »       »       this.player.UpdateFromEitherPlayerDataOrCache(data,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null);
43 »       »       »       this.player.SetHatAndVisorMaskType(PlayerMaterial.MaskType.None);43 »       »       »       this.player.SetHatAndVisorMaskType(PlayerMaterial.MaskType.None);
44 »       »       »       base.StartCoroutine(this.CoSetPlayerRendererIndexes());44 »       »       »       base.StartCoroutine(this.CoSetPlayerRendererIndexes());
45 »       »       »       this.playerColorBackgrounds.ForEach(delegate(SpriteRenderer·x)45 »       »       »       this.playerColorBackgrounds.ForEach(delegate(SpriteRenderer·x)
46 »       »       »       {46 »       »       »       {
47 »       »       »       »       x.color·=·base.Phrase.ToPlayerBackgroundColor();47 »       »       »       »       x.color·=·base.Phrase.ToPlayerBackgroundColor();
48 »       »       »       });48 »       »       »       });
418 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuPhrasesPagePhraseButton.cs
Ordering differences only
    
Offset 87, 12 lines modifiedOffset 87, 12 lines modified
87 »       »       }87 »       »       }
88 88
89 »       »       private·void·OnFavoritePressed()89 »       »       private·void·OnFavoritePressed()
90 »       »       {90 »       »       {
91 »       »       »       this.ToggleFavorite();91 »       »       »       this.ToggleFavorite();
92 »       »       }92 »       »       }
93 93
94 »       »       [Header("Phrase·Button")] 
95 »       »       [SerializeField]94 »       »       [SerializeField]
 95 »       »       [Header("Phrase·Button")]
96 »       »       private·QuickChatFavoriteIcon·favoriteIcon;96 »       »       private·QuickChatFavoriteIcon·favoriteIcon;
97 »       }97 »       }
98 }98 }
683 B
Assembly-CSharp/Amongus/QuickChat/QuickChatMenuScroller.cs
Ordering differences only
    
Offset 127, 23 lines modifiedOffset 127, 23 lines modified
127 127
128 »       »       [SerializeField]128 »       »       [SerializeField]
129 »       »       private·BoxCollider2D·collider;129 »       »       private·BoxCollider2D·collider;
130 130
131 »       »       [SerializeField]131 »       »       [SerializeField]
132 »       »       private·ScrollToSelection·scrollToSelection;132 »       »       private·ScrollToSelection·scrollToSelection;
133 133
134 »       »       [Header("Gradients")] 
135 »       »       [SerializeField]134 »       »       [SerializeField]
 135 »       »       [Header("Gradients")]
136 »       »       private·SpriteRenderer·topGradient;136 »       »       private·SpriteRenderer·topGradient;
137 137
138 »       »       [SerializeField]138 »       »       [SerializeField]
139 »       »       private·Transform·topGradientContainer;139 »       »       private·Transform·topGradientContainer;
140 140
141 »       »       [Space(10f)] 
142 »       »       [SerializeField]141 »       »       [SerializeField]
 142 »       »       [Space(10f)]
143 »       »       private·SpriteRenderer·bottomGradient;143 »       »       private·SpriteRenderer·bottomGradient;
144 144
145 »       »       [SerializeField]145 »       »       [SerializeField]
146 »       »       private·Transform·bottomGradientContainer;146 »       »       private·Transform·bottomGradientContainer;
147 147
148 »       »       private·float·width;148 »       »       private·float·width;
149 149
730 B
Assembly-CSharp/Amongus/QuickChat/QuickChatPhrase.cs
    
Offset 178, 15 lines modifiedOffset 178, 15 lines modified
178 »       »       private·string·ToPlayerNameText(bool·boldPlayerName)178 »       »       private·string·ToPlayerNameText(bool·boldPlayerName)
179 »       »       {179 »       »       {
180 »       »       »       if·(this.PlayerId·==·255)180 »       »       »       if·(this.PlayerId·==·255)
181 »       »       »       {181 »       »       »       {
182 »       »       »       »       QuickChatMenu.Logger.Error("[QuickChatPhrase]·ToPlayerNameText()·::·'playerId'·was·empty·or·uninitialized.·Returning·null·string.",·null);182 »       »       »       »       QuickChatMenu.Logger.Error("[QuickChatPhrase]·ToPlayerNameText()·::·'playerId'·was·empty·or·uninitialized.·Returning·null·string.",·null);
183 »       »       »       »       return·null;183 »       »       »       »       return·null;
184 »       »       »       }184 »       »       »       }
185 »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.PlayerId);185 »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.PlayerId);
186 »       »       »       if·(!boldPlayerName)186 »       »       »       if·(!boldPlayerName)
187 »       »       »       {187 »       »       »       {
188 »       »       »       »       return·playerById.PlayerName;188 »       »       »       »       return·playerById.PlayerName;
189 »       »       »       }189 »       »       »       }
190 »       »       »       return·QuickChatPhrase.AddBoldTagsIfSupported(playerById.PlayerName);190 »       »       »       return·QuickChatPhrase.AddBoldTagsIfSupported(playerById.PlayerName);
191 »       »       }191 »       »       }
192 192
1.12 KB
Assembly-CSharp/Amongus/QuickChat/QuickChatPhraseAsset.cs
Ordering differences only
    
Offset 104, 43 lines modifiedOffset 104, 43 lines modified
104 »       »       »       »       »       }104 »       »       »       »       »       }
105 »       »       »       »       »       this.cachedPhrase·=·QuickChatPhrase.NewComplexPhrase(this.key,·array,·this.isNegative);105 »       »       »       »       »       this.cachedPhrase·=·QuickChatPhrase.NewComplexPhrase(this.key,·array,·this.isNegative);
106 »       »       »       »       }106 »       »       »       »       }
107 »       »       »       }107 »       »       »       }
108 »       »       »       return·this.cachedPhrase;108 »       »       »       return·this.cachedPhrase;
109 »       »       }109 »       »       }
110 110
111 »       »       [Header("Phrase·Properties")] 
112 »       »       [SerializeField]111 »       »       [SerializeField]
 112 »       »       [Header("Phrase·Properties")]
113 »       »       private·string·text;113 »       »       private·string·text;
114 114
115 »       »       [SerializeField]115 »       »       [SerializeField]
116 »       »       private·StringNames·key;116 »       »       private·StringNames·key;
117 117
118 »       »       [SerializeField]118 »       »       [SerializeField]
119 »       »       private·Sprite·icon;119 »       »       private·Sprite·icon;
120 120
121 »       »       [SerializeField]121 »       »       [SerializeField]
122 »       »       private·int·order;122 »       »       private·int·order;
123 123
124 »       »       [SerializeField] 
125 »       »       [Header("Usage")]124 »       »       [Header("Usage")]
 125 »       »       [SerializeField]
126 »       »       private·bool·isInput;126 »       »       private·bool·isInput;
127 127
128 »       »       [SerializeField]128 »       »       [SerializeField]
129 »       »       private·bool·isNegative;129 »       »       private·bool·isNegative;
130 130
131 »       »       [Space(10f)]131 »       »       [Space(10f)]
132 »       »       [SerializeField]132 »       »       [SerializeField]
133 »       »       private·QuickChatTag[]·tags;133 »       »       private·QuickChatTag[]·tags;
134 134
135 »       »       [SerializeField]135 »       »       [SerializeField]
136 »       »       private·QuickChatPhraseInput[]·inputs;136 »       »       private·QuickChatPhraseInput[]·inputs;
137 137
138 »       »       [Header("Inclusion·Rules")] 
139 »       »       [SerializeField]138 »       »       [SerializeField]
 139 »       »       [Header("Inclusion·Rules")]
140 »       »       private·QuickChatClassicPhraseRules·classicRules;140 »       »       private·QuickChatClassicPhraseRules·classicRules;
141 141
142 »       »       [SerializeField]142 »       »       [SerializeField]
143 »       »       private·QuickChatHideAndSeekPhraseRules·hideAndSeekRules;143 »       »       private·QuickChatHideAndSeekPhraseRules·hideAndSeekRules;
144 144
145 »       »       private·QuickChatPhrase·cachedPhrase;145 »       »       private·QuickChatPhrase·cachedPhrase;
146 »       }146 »       }
832 B
Assembly-CSharp/Amongus/QuickChat/QuickChatPhraseBuilderResult.cs
    
Offset 56, 15 lines modifiedOffset 56, 15 lines modified
56 »       »       »       »       return·"ERROR";56 »       »       »       »       return·"ERROR";
57 »       »       »       }57 »       »       »       }
58 »       »       »       if·(playerID·==·255)58 »       »       »       if·(playerID·==·255)
59 »       »       »       {59 »       »       »       {
60 »       »       »       »       QuickChatMenu.Logger.Warning("[QuickChatPhraseBuilderResult]·ToPlayerNameChatText()·Player·ID·is·empty.",·null);60 »       »       »       »       QuickChatMenu.Logger.Warning("[QuickChatPhraseBuilderResult]·ToPlayerNameChatText()·Player·ID·is·empty.",·null);
61 »       »       »       »       return·"ERROR";61 »       »       »       »       return·"ERROR";
62 »       »       »       }62 »       »       »       }
63 »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(playerID);63 »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(playerID);
64 »       »       »       if·(playerById·==·null)64 »       »       »       if·(playerById·==·null)
65 »       »       »       {65 »       »       »       {
66 »       »       »       »       QuickChatMenu.Logger.Warning(string.Format("[{0}]·ToPlayerNameChatText()·Player·with·associated·ID·'{1}'·was·not·found.",·"QuickChatPhraseBuilderResult",·playerID),·null);66 »       »       »       »       QuickChatMenu.Logger.Warning(string.Format("[{0}]·ToPlayerNameChatText()·Player·with·associated·ID·'{1}'·was·not·found.",·"QuickChatPhraseBuilderResult",·playerID),·null);
67 »       »       »       »       return·"ERROR";67 »       »       »       »       return·"ERROR";
68 »       »       »       }68 »       »       »       }
69 »       »       »       if·(DataManager.Settings.Accessibility.ColorBlindMode)69 »       »       »       if·(DataManager.Settings.Accessibility.ColorBlindMode)
70 »       »       »       {70 »       »       »       {
586 B
Assembly-CSharp/Amongus/QuickChat/QuickChatPreviewField.cs
Ordering differences only
    
Offset 136, 16 lines modifiedOffset 136, 16 lines modified
136 »       »       »       »       {136 »       »       »       »       {
137 »       »       »       »       »       text·+=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.QuickChatInstructionsChild,·Array.Empty<object>());137 »       »       »       »       »       text·+=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.QuickChatInstructionsChild,·Array.Empty<object>());
138 »       »       »       »       }138 »       »       »       »       }
139 »       »       »       }139 »       »       »       }
140 »       »       »       return·text;140 »       »       »       return·text;
141 »       »       }141 »       »       }
142 142
143 »       »       [Space(10f)] 
144 »       »       [SerializeField]143 »       »       [SerializeField]
 144 »       »       [Space(10f)]
145 »       »       private·ChatInputFieldButton·clearButton;145 »       »       private·ChatInputFieldButton·clearButton;
146 146
147 »       »       [SerializeField]147 »       »       [SerializeField]
148 »       »       private·ChatInputFieldButton·undoButton;148 »       »       private·ChatInputFieldButton·undoButton;
149 149
150 »       »       [SerializeField]150 »       »       [SerializeField]
151 »       »       private·TextMeshPro·warningText;151 »       »       private·TextMeshPro·warningText;
421 B
Assembly-CSharp/Amongus/QuickChat/QuickChatTag.cs
Ordering differences only
    
Offset 64, 15 lines modifiedOffset 64, 15 lines modified
64 64
65 »       »       [SerializeField]65 »       »       [SerializeField]
66 »       »       private·StringNames·tagKey;66 »       »       private·StringNames·tagKey;
67 67
68 »       »       [SerializeField]68 »       »       [SerializeField]
69 »       »       private·StringNames·inputKey;69 »       »       private·StringNames·inputKey;
70 70
71 »       »       [ColorUsage(false)] 
72 »       »       [SerializeField]71 »       »       [SerializeField]
 72 »       »       [ColorUsage(false)]
73 »       »       private·Color·color;73 »       »       private·Color·color;
74 74
75 »       »       [SerializeField]75 »       »       [SerializeField]
76 »       »       private·string[]·parsingKeys;76 »       »       private·string[]·parsingKeys;
77 »       }77 »       }
78 }78 }
559 B
Assembly-CSharp/Amongus/QuickChat/QuickChatTagAssets.cs
Ordering differences only
    
Offset 245, 16 lines modifiedOffset 245, 16 lines modified
245 245
246 »       »       [SerializeField]246 »       »       [SerializeField]
247 »       »       private·QuickChatTag·lobbyHiding;247 »       »       private·QuickChatTag·lobbyHiding;
248 248
249 »       »       [SerializeField]249 »       »       [SerializeField]
250 »       »       private·QuickChatTag·lobbyFlashlight;250 »       »       private·QuickChatTag·lobbyFlashlight;
251 251
252 »       »       [Header("Collections")] 
253 »       »       [SerializeField]252 »       »       [SerializeField]
 253 »       »       [Header("Collections")]
254 »       »       private·QuickChatTag[]·visibleInClassicLobby;254 »       »       private·QuickChatTag[]·visibleInClassicLobby;
255 255
256 »       »       [SerializeField]256 »       »       [SerializeField]
257 »       »       private·QuickChatTag[]·visibleInHideAndSeekLobby;257 »       »       private·QuickChatTag[]·visibleInHideAndSeekLobby;
258 258
259 »       »       [SerializeField]259 »       »       [SerializeField]
260 »       »       private·QuickChatTag[]·visibleInGame;260 »       »       private·QuickChatTag[]·visibleInGame;
20.4 KB
Assembly-CSharp/AmongUsClient.cs
    
Offset 190, 14 lines modifiedOffset 190, 16 lines modified
190 »       »       »       DestroyableSingleton<WaitForHostPopup>.Instance.Hide();190 »       »       »       DestroyableSingleton<WaitForHostPopup>.Instance.Hide();
191 »       »       }191 »       »       }
192 »       »       base.StopAllCoroutines();192 »       »       base.StopAllCoroutines();
193 »       »       this.AbortLoadingAssets();193 »       »       this.AbortLoadingAssets();
194 »       »       DestroyableSingleton<FriendsListManager>.Instance.ReparentUI();194 »       »       DestroyableSingleton<FriendsListManager>.Instance.ReparentUI();
195 »       »       SoundManager.Instance.StopAllSound();195 »       »       SoundManager.Instance.StopAllSound();
196 »       »       this.discoverState·=·DiscoveryState.Off;196 »       »       this.discoverState·=·DiscoveryState.Off;
 197 »       »       this.DestroyPlayerInfoObjects();
 198 »       »       GameData.DestroyInstance();
197 »       »       this.DisconnectHandlers.Clear();199 »       »       this.DisconnectHandlers.Clear();
198 »       »       base.DisconnectInternal(reason,·null);200 »       »       base.DisconnectInternal(reason,·null);
199 »       »       DestroyableSingleton<AchievementManager>.Instance.OnMatchExited();201 »       »       DestroyableSingleton<AchievementManager>.Instance.OnMatchExited();
200 »       »       GameDebugCommands.RemoveCommands();202 »       »       GameDebugCommands.RemoveCommands();
201 »       »       global::Logger.GlobalInstance.Debug("Loading·new·scene·"·+·this.MainMenuScene,·null);203 »       »       global::Logger.GlobalInstance.Debug("Loading·new·scene·"·+·this.MainMenuScene,·null);
202 »       »       SceneManager.LoadScene(this.MainMenuScene);204 »       »       SceneManager.LoadScene(this.MainMenuScene);
203 »       »       global::Logger.GlobalInstance.Debug("Finished·loading·scene",·null);205 »       »       global::Logger.GlobalInstance.Debug("Finished·loading·scene",·null);
Offset 280, 18 lines modifiedOffset 282, 18 lines modified
280 »       »       »       ShipStatus.Instance·=·result.GetComponent<ShipStatus>();282 »       »       »       ShipStatus.Instance·=·result.GetComponent<ShipStatus>();
281 »       »       »       base.Spawn(ShipStatus.Instance,·-2,·SpawnFlags.None);283 »       »       »       base.Spawn(ShipStatus.Instance,·-2,·SpawnFlags.None);
282 »       »       }284 »       »       }
283 »       »       float·timer·=·0f;285 »       »       float·timer·=·0f;
284 »       »       for·(;;)286 »       »       for·(;;)
285 »       »       {287 »       »       {
286 »       »       »       bool·stopWaiting·=·true;288 »       »       »       bool·stopWaiting·=·true;
287 »       »       »       int·num2·=·this.MAX_CLIENT_WAIT_TIME;289 »       »       »       int·num2·=·10;
288 »       »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4)290 »       »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4)
289 »       »       »       {291 »       »       »       {
290 »       »       »       »       num2·=·this.MAX_CLIENT_WAIT_TIME·+·5;292 »       »       »       »       num2·=·15;
291 »       »       »       }293 »       »       »       }
292 »       »       »       List<ClientData>·allClients·=·this.allClients;294 »       »       »       List<ClientData>·allClients·=·this.allClients;
293 »       »       »       lock·(allClients)295 »       »       »       lock·(allClients)
294 »       »       »       {296 »       »       »       {
295 »       »       »       »       for·(int·i·=·0;·i·<·this.allClients.Count;·i++)297 »       »       »       »       for·(int·i·=·0;·i·<·this.allClients.Count;·i++)
296 »       »       »       »       {298 »       »       »       »       {
297 »       »       »       »       »       ClientData·clientData·=·this.allClients[i];299 »       »       »       »       »       ClientData·clientData·=·this.allClients[i];
Offset 319, 25 lines modifiedOffset 321, 45 lines modified
319 »       »       }321 »       »       }
320 »       »       DestroyableSingleton<RoleManager>.Instance.SelectRoles();322 »       »       DestroyableSingleton<RoleManager>.Instance.SelectRoles();
321 »       »       ShipStatus.Instance.Begin();323 »       »       ShipStatus.Instance.Begin();
322 »       »       base.SendClientReady();324 »       »       base.SendClientReady();
323 »       »       yield·break;325 »       »       yield·break;
324 »       }326 »       }
325 327
 328 »       public·void·KickNotJoinedPlayers()
 329 »       {
 330 »       »       if·(!base.AmHost)
 331 »       »       {
 332 »       »       »       return;
 333 »       »       }
 334 »       »       List<ClientData>·allClients·=·this.allClients;
 335 »       »       lock·(allClients)
 336 »       »       {
 337 »       »       »       for·(int·i·=·0;·i·<·this.allClients.Count;·i++)
 338 »       »       »       {
 339 »       »       »       »       ClientData·clientData·=·this.allClients[i];
 340 »       »       »       »       if·(clientData.Character·==·null)
 341 »       »       »       »       {
 342 »       »       »       »       »       base.SendLateRejection(clientData.Id,·DisconnectReasons.Error);
 343 »       »       »       »       }
 344 »       »       »       }
 345 »       »       }
 346 »       }
 347
326 »       protected·IEnumerator·CoStartGameClient()348 »       protected·IEnumerator·CoStartGameClient()
327 »       {349 »       {
328 »       »       while·(PlayerControl.LocalPlayer.Data·==·null·&&·!base.AmHost)350 »       »       while·(PlayerControl.LocalPlayer.Data·==·null·&&·!base.AmHost)
329 »       »       {351 »       »       {
330 »       »       »       yield·return·null;352 »       »       »       yield·return·null;
331 »       »       }353 »       »       }
332 »       »       float·timer·=·0f;354 »       »       float·timer·=·0f;
333 »       »       float·timeOut·=·(float)(this.MAX_CLIENT_WAIT_TIME·+·5);355 »       »       float·timeOut·=·15f;
334 »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4)356 »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.MapId·==·5·||·GameOptionsManager.Instance.CurrentGameOptions.MapId·==·4)
335 »       »       {357 »       »       {
336 »       »       »       timeOut·=·(float)(this.MAX_CLIENT_WAIT_TIME·+·10);358 »       »       »       timeOut·=·20f;
337 »       »       }359 »       »       }
338 »       »       while·(!ShipStatus.Instance·||·LobbyBehaviour.Instance)360 »       »       while·(!ShipStatus.Instance·||·LobbyBehaviour.Instance)
339 »       »       {361 »       »       {
340 »       »       »       if·(base.AmHost)362 »       »       »       if·(base.AmHost)
341 »       »       »       {363 »       »       »       {
342 »       »       »       »       yield·break;364 »       »       »       »       yield·break;
343 »       »       »       }365 »       »       »       }
Offset 429, 14 lines modifiedOffset 451, 18 lines modified
429 »       »       »       gameSettingMenu.Close();451 »       »       »       gameSettingMenu.Close();
430 »       »       }452 »       »       }
431 »       »       if·(DestroyableSingleton<GameStartManager>.InstanceExists)453 »       »       if·(DestroyableSingleton<GameStartManager>.InstanceExists)
432 »       »       {454 »       »       {
433 »       »       »       this.DisconnectHandlers.Remove(DestroyableSingleton<GameStartManager>.Instance);455 »       »       »       this.DisconnectHandlers.Remove(DestroyableSingleton<GameStartManager>.Instance);
434 »       »       »       Object.Destroy(DestroyableSingleton<GameStartManager>.Instance.gameObject);456 »       »       »       Object.Destroy(DestroyableSingleton<GameStartManager>.Instance.gameObject);
435 »       »       }457 »       »       }
 458 »       »       if·(DestroyableSingleton<LobbyInfoPane>.InstanceExists)
 459 »       »       {
 460 »       »       »       Object.Destroy(DestroyableSingleton<LobbyInfoPane>.Instance.gameObject);
 461 »       »       }
436 »       »       if·(DestroyableSingleton<DiscordManager>.InstanceExists)462 »       »       if·(DestroyableSingleton<DiscordManager>.InstanceExists)
437 »       »       {463 »       »       {
438 »       »       »       DestroyableSingleton<DiscordManager>.Instance.SetPlayingGame();464 »       »       »       DestroyableSingleton<DiscordManager>.Instance.SetPlayingGame();
439 »       »       }465 »       »       }
440 »       »       if·(!string.IsNullOrEmpty(DataManager.Player.Store.ActiveCosmicube))466 »       »       if·(!string.IsNullOrEmpty(DataManager.Player.Store.ActiveCosmicube))
441 »       »       {467 »       »       {
442 »       »       »       AmongUsClient.Instance.SetActivePodType(DestroyableSingleton<CosmicubeManager>.Instance.GetCubeDataByID(DataManager.Player.Store.ActiveCosmicube).podId);468 »       »       »       AmongUsClient.Instance.SetActivePodType(DestroyableSingleton<CosmicubeManager>.Instance.GetCubeDataByID(DataManager.Player.Store.ActiveCosmicube).podId);
Offset 447, 25 lines modifiedOffset 473, 20 lines modified
447 »       »       »       AmongUsClient.Instance.SetActivePodType(playerPrefs.ActivePodType);473 »       »       »       AmongUsClient.Instance.SetActivePodType(playerPrefs.ActivePodType);
448 »       »       }474 »       »       }
449 »       »       DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.Cancel();475 »       »       DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.Cancel();
450 »       »       DestroyableSingleton<FriendsListManager>.Instance.Ui.Close(true);476 »       »       DestroyableSingleton<FriendsListManager>.Instance.Ui.Close(true);
451 »       »       DestroyableSingleton<FriendsListManager>.Instance.ReparentUI();477 »       »       DestroyableSingleton<FriendsListManager>.Instance.ReparentUI();
452 »       »       CosmeticsCache.ClearUnusedCosmetics();478 »       »       CosmeticsCache.ClearUnusedCosmetics();
453 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·true);479 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·true);
454 »       »       while·(!GameData.Instance) 
455 »       »       { 
456 »       »       »       yield·return·null; 
457 »       »       } 
458 »       »       StatsManager·instance·=·StatsManager.Instance;480 »       »       StatsManager·instance·=·StatsManager.Instance;
459 »       »       float·banPoints·=·instance.BanPoints;481 »       »       float·banPoints·=·instance.BanPoints;
460 »       »       instance.BanPoints·=·banPoints·+·1f;482 »       »       instance.BanPoints·=·banPoints·+·1f;
461 »       »       StatsManager.Instance.LastGameStarted·=·DateTime.UtcNow;483 »       »       StatsManager.Instance.LastGameStarted·=·DateTime.UtcNow;
462 »       »       if·(base.AmHost)484 »       »       if·(base.AmHost)
463 »       »       {485 »       »       {
464 »       »       »       GameData.Instance.SetDirty(); 
465 »       »       »       yield·return·this.CoStartGameHost();486 »       »       »       yield·return·this.CoStartGameHost();
466 »       »       }487 »       »       }
467 »       »       else488 »       »       else
468 »       »       {489 »       »       {
469 »       »       »       yield·return·this.CoStartGameClient();490 »       »       »       yield·return·this.CoStartGameClient();
470 »       »       »       if·(base.AmHost)491 »       »       »       if·(base.AmHost)
471 »       »       »       {492 »       »       »       {
Offset 483, 22 lines modifiedOffset 504, 22 lines modified
Max diff block lines reached; 16340/20790 bytes (78.60%) of diff not shown.
1.53 KB
Assembly-CSharp/ArrowBehaviour.cs
    
Offset 46, 19 lines modifiedOffset 46, 24 lines modified
46 »       {46 »       {
47 »       »       return·value·>·min·&&·value·<·max;47 »       »       return·value·>·min·&&·value·<·max;
48 »       }48 »       }
49 49
50 »       protected·virtual·void·CloseBehaviour(Vector2·del,·float·delLen)50 »       protected·virtual·void·CloseBehaviour(Vector2·del,·float·delLen)
51 »       {51 »       {
52 »       »       base.transform.position·=·this.target·-·del.normalized·*·0.6f;52 »       »       base.transform.position·=·this.target·-·del.normalized·*·0.6f;
 53 »       »       if·(this.alwaysMaxSize)
 54 »       »       {
 55 »       »       »       base.transform.localScale·=·new·Vector3(this.MaxScale,·this.MaxScale,·this.MaxScale);
 56 »       »       »       return;
 57 »       »       }
53 »       »       float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale);58 »       »       float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale);
54 »       »       base.transform.localScale·=·new·Vector3(num,·num,·num);59 »       »       base.transform.localScale·=·new·Vector3(num,·num,·num);
55 »       }60 »       }
56 61
57 »       protected·void·DistancedBehaviour(Vector2·vpPoint,·Vector2·del,·float·delLen,·Camera·cam)62 »       protected·virtual·void·DistancedBehaviour(Vector2·vpPoint,·Vector2·del,·float·delLen,·Camera·cam)
58 »       {63 »       {
59 »       »       Vector2·vector·=·new·Vector2(Mathf.Clamp(vpPoint.x·*·2f·-·1f,·-1f,·1f),·Mathf.Clamp(vpPoint.y·*·2f·-·1f,·-1f,·1f));64 »       »       Vector2·vector·=·new·Vector2(Mathf.Clamp(vpPoint.x·*·2f·-·1f,·-1f,·1f),·Mathf.Clamp(vpPoint.y·*·2f·-·1f,·-1f,·1f));
60 »       »       float·safeOrthographicSize·=·CameraSafeArea.GetSafeOrthographicSize(cam);65 »       »       float·safeOrthographicSize·=·CameraSafeArea.GetSafeOrthographicSize(cam);
61 »       »       float·num·=·safeOrthographicSize·*·cam.aspect;66 »       »       float·num·=·safeOrthographicSize·*·cam.aspect;
62 »       »       Vector3·vector2·=·new·Vector3(Mathf.LerpUnclamped(0f,·num·*·0.88f,·vector.x),·Mathf.LerpUnclamped(0f,·safeOrthographicSize·*·0.79f,·vector.y),·0f);67 »       »       Vector3·vector2·=·new·Vector3(Mathf.LerpUnclamped(0f,·num·*·0.88f,·vector.x),·Mathf.LerpUnclamped(0f,·safeOrthographicSize·*·0.79f,·vector.y),·0f);
63 »       »       base.transform.position·=·cam.transform.position·+·vector2;68 »       »       base.transform.position·=·cam.transform.position·+·vector2;
64 »       »       base.transform.localScale·=·new·Vector3(this.MaxScale,·this.MaxScale,·this.MaxScale);69 »       »       base.transform.localScale·=·new·Vector3(this.MaxScale,·this.MaxScale,·this.MaxScale);
Offset 66, 12 lines modifiedOffset 71, 14 lines modified
66 71
67 »       public·Vector3·target;72 »       public·Vector3·target;
68 73
69 »       public·float·perc·=·0.925f;74 »       public·float·perc·=·0.925f;
70 75
71 »       public·float·MaxScale·=·1f;76 »       public·float·MaxScale·=·1f;
72 77
 78 »       public·bool·alwaysMaxSize;
 79
73 »       protected·float·minDistanceToShowArrow·=·0.3f;80 »       protected·float·minDistanceToShowArrow·=·0.3f;
74 81
75 »       [HideInInspector]82 »       [HideInInspector]
76 »       public·SpriteRenderer·image;83 »       public·SpriteRenderer·image;
77 }84 }
720 B
Assembly-CSharp/AspectScaledAsset.cs
Ordering differences only
    
Offset 58, 20 lines modifiedOffset 58, 20 lines modified
58 »       »       });58 »       »       });
59 »       »       if·(this.aspectPosition)59 »       »       if·(this.aspectPosition)
60 »       »       {60 »       »       {
61 »       »       »       this.aspectPosition.DistanceFromEdge.x·=·this.originalDistanceFromEdge·+·(float)this.positionDirection·*·((this.allSprites[0].OriginalWidth·-·this.allSprites[0].Sprite.size.x)·/·2f);61 »       »       »       this.aspectPosition.DistanceFromEdge.x·=·this.originalDistanceFromEdge·+·(float)this.positionDirection·*·((this.allSprites[0].OriginalWidth·-·this.allSprites[0].Sprite.size.x)·/·2f);
62 »       »       }62 »       »       }
63 »       }63 »       }
64 64
65 »       [SerializeField] 
66 »       [Header("Required")]65 »       [Header("Required")]
 66 »       [SerializeField]
67 »       private·List<SpriteRenderer>·spritesToScale;67 »       private·List<SpriteRenderer>·spritesToScale;
68 68
69 »       [Header("Optional")] 
70 »       [SerializeField]69 »       [SerializeField]
 70 »       [Header("Optional")]
71 »       private·AspectPosition·aspectPosition;71 »       private·AspectPosition·aspectPosition;
72 72
73 »       [SerializeField]73 »       [SerializeField]
74 »       private·int·positionDirection·=·1;74 »       private·int·positionDirection·=·1;
75 75
76 »       [SerializeField]76 »       [SerializeField]
77 »       private·List<BoxCollider2D>·collidersToScale;77 »       private·List<BoxCollider2D>·collidersToScale;
26.0 KB
Assembly-CSharp/Assembly-CSharp.csproj
26.0 KB
Assembly-CSharp/Assembly-CSharp.csproj
    
Offset 1, 14 lines modifiedOffset 1, 14 lines modified
1 <?xml·version="1.0"·encoding="utf-8"?>1 <?xml·version="1.0"·encoding="utf-8"?>
2 <Project·xmlns="http://schemas.microsoft.com/developer/msbuild/2003"·ToolsVersion="15.0">2 <Project·xmlns="http://schemas.microsoft.com/developer/msbuild/2003"·ToolsVersion="15.0">
3 ··<Import·Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"·Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/>3 ··<Import·Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"·Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/>
4 ··<PropertyGroup>4 ··<PropertyGroup>
5 ····<Configuration·Condition="·'$(Configuration)'·==·''·">Debug</Configuration>5 ····<Configuration·Condition="·'$(Configuration)'·==·''·">Debug</Configuration>
6 ····<Platform·Condition="·'$(Platform)'·==·''·">AnyCPU</Platform>6 ····<Platform·Condition="·'$(Platform)'·==·''·">AnyCPU</Platform>
7 ····<ProjectGuid>{925A90A8-5FCD-47D1-994B-4A6372AB4948}</ProjectGuid>7 ····<ProjectGuid>{2B08EEB2-0341-466B-8A98-2B231743DC3D}</ProjectGuid>
8 ····<OutputType>Library</OutputType>8 ····<OutputType>Library</OutputType>
9 ····<RootNamespace>Assembly-CSharp</RootNamespace>9 ····<RootNamespace>Assembly-CSharp</RootNamespace>
10 ····<AssemblyName>Assembly-CSharp</AssemblyName>10 ····<AssemblyName>Assembly-CSharp</AssemblyName>
11 ····<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>11 ····<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
12 ····<FileAlignment>512</FileAlignment>12 ····<FileAlignment>512</FileAlignment>
13 ··</PropertyGroup>13 ··</PropertyGroup>
14 ··<PropertyGroup·Condition="·'$(Configuration)|$(Platform)'·==·'Debug|AnyCPU'·">14 ··<PropertyGroup·Condition="·'$(Configuration)|$(Platform)'·==·'Debug|AnyCPU'·">
Offset 141, 15 lines modifiedOffset 141, 15 lines modified
141 ····<Compile·Include="AchievementManager.cs"/>141 ····<Compile·Include="AchievementManager.cs"/>
142 ····<Compile·Include="ActionButton.cs"/>142 ····<Compile·Include="ActionButton.cs"/>
143 ····<Compile·Include="ActionMapGlyphDisplay.cs"/>143 ····<Compile·Include="ActionMapGlyphDisplay.cs"/>
144 ····<Compile·Include="ActiveInputManager.cs"/>144 ····<Compile·Include="ActiveInputManager.cs"/>
145 ····<Compile·Include="AdDataCollectScreen.cs"/>145 ····<Compile·Include="AdDataCollectScreen.cs"/>
146 ····<Compile·Include="AdjustSteeringGame.cs"/>146 ····<Compile·Include="AdjustSteeringGame.cs"/>
147 ····<Compile·Include="AdminButton.cs"/>147 ····<Compile·Include="AdminButton.cs"/>
148 ····<Compile·Include="AdvancedRoleSettingsButton.cs"/>148 ····<Compile·Include="AdvancedRoleViewPanel.cs"/>
149 ····<Compile·Include="AgeGateScreen.cs"/>149 ····<Compile·Include="AgeGateScreen.cs"/>
150 ····<Compile·Include="AirshipAuthGame.cs"/>150 ····<Compile·Include="AirshipAuthGame.cs"/>
151 ····<Compile·Include="AirshipExileController.cs"/>151 ····<Compile·Include="AirshipExileController.cs"/>
152 ····<Compile·Include="AirshipGarbageGame.cs"/>152 ····<Compile·Include="AirshipGarbageGame.cs"/>
153 ····<Compile·Include="AirshipStatus.cs"/>153 ····<Compile·Include="AirshipStatus.cs"/>
154 ····<Compile·Include="AirshipUploadGame.cs"/>154 ····<Compile·Include="AirshipUploadGame.cs"/>
155 ····<Compile·Include="AirshipUploadTask.cs"/>155 ····<Compile·Include="AirshipUploadTask.cs"/>
Offset 158, 14 lines modifiedOffset 158, 32 lines modified
158 ····<Compile·Include="AlphaBlink.cs"/>158 ····<Compile·Include="AlphaBlink.cs"/>
159 ····<Compile·Include="AlphaPulse.cs"/>159 ····<Compile·Include="AlphaPulse.cs"/>
160 ····<Compile·Include="AmbientSoundPlayer.cs"/>160 ····<Compile·Include="AmbientSoundPlayer.cs"/>
161 ····<Compile·Include="AmongUsClient.cs"/>161 ····<Compile·Include="AmongUsClient.cs"/>
162 ····<Compile·Include="AmongUsControlMapper.cs"/>162 ····<Compile·Include="AmongUsControlMapper.cs"/>
163 ····<Compile·Include="AmongUsProduct.cs"/>163 ····<Compile·Include="AmongUsProduct.cs"/>
164 ····<Compile·Include="AmongUsServer\ExtensionFailureReasons.cs"/>164 ····<Compile·Include="AmongUsServer\ExtensionFailureReasons.cs"/>
 165 ····<Compile·Include="AmongUs\AnimationTestScene\AbstractAnimationTestScenePage.cs"/>
 166 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScene.cs"/>
 167 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneButton.cs"/>
 168 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPage.cs"/>
 169 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageBuilder.cs"/>
 170 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageBuilderPresetButton.cs"/>
 171 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageBuilderSprite.cs"/>
 172 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneColorsPageRenderer.cs"/>
 173 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneCosmeticData.cs"/>
 174 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneEjectPage.cs"/>
 175 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneExitPage.cs"/>
 176 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneInfoPage.cs"/>
 177 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneKillPage.cs"/>
 178 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneMeetingPage.cs"/>
 179 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScenePetsPage.cs"/>
 180 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScenePlayerPage.cs"/>
 181 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestScenePlayerPageBodyToggle.cs"/>
 182 ····<Compile·Include="AmongUs\AnimationTestScene\AnimationTestSceneTab.cs"/>
165 ····<Compile·Include="AmongUs\Data\AbstractSaveData.cs"/>183 ····<Compile·Include="AmongUs\Data\AbstractSaveData.cs"/>
166 ····<Compile·Include="AmongUs\Data\AbstractSaveDataGroup.cs"/>184 ····<Compile·Include="AmongUs\Data\AbstractSaveDataGroup.cs"/>
167 ····<Compile·Include="AmongUs\Data\AbstractUserSaveData.cs"/>185 ····<Compile·Include="AmongUs\Data\AbstractUserSaveData.cs"/>
168 ····<Compile·Include="AmongUs\Data\DataManager.cs"/>186 ····<Compile·Include="AmongUs\Data\DataManager.cs"/>
169 ····<Compile·Include="AmongUs\Data\ISaveDataGroupControl.cs"/>187 ····<Compile·Include="AmongUs\Data\ISaveDataGroupControl.cs"/>
170 ····<Compile·Include="AmongUs\Data\Legacy\LegacySaveManager.cs"/>188 ····<Compile·Include="AmongUs\Data\Legacy\LegacySaveManager.cs"/>
171 ····<Compile·Include="AmongUs\Data\Legacy\LegacySecureDataFile.cs"/>189 ····<Compile·Include="AmongUs\Data\Legacy\LegacySecureDataFile.cs"/>
Offset 187, 38 lines modifiedOffset 205, 52 lines modified
187 ····<Compile·Include="AmongUs\Data\Settings\MultiplayerSettingsData.cs"/>205 ····<Compile·Include="AmongUs\Data\Settings\MultiplayerSettingsData.cs"/>
188 ····<Compile·Include="AmongUs\Data\Settings\SettingsData.cs"/>206 ····<Compile·Include="AmongUs\Data\Settings\SettingsData.cs"/>
189 ····<Compile·Include="AmongUs\Data\Settings\VideoSettingsData.cs"/>207 ····<Compile·Include="AmongUs\Data\Settings\VideoSettingsData.cs"/>
190 ····<Compile·Include="Amongus\GameModes\HideAndSeek\HideAndSeekMusicCollection.cs"/>208 ····<Compile·Include="Amongus\GameModes\HideAndSeek\HideAndSeekMusicCollection.cs"/>
191 ····<Compile·Include="AmongUs\GameOptions\BoolOptionNames.cs"/>209 ····<Compile·Include="AmongUs\GameOptions\BoolOptionNames.cs"/>
192 ····<Compile·Include="AmongUs\GameOptions\ByteOptionNames.cs"/>210 ····<Compile·Include="AmongUs\GameOptions\ByteOptionNames.cs"/>
193 ····<Compile·Include="AmongUs\GameOptions\EngineerRoleOptionsV07.cs"/>211 ····<Compile·Include="AmongUs\GameOptions\EngineerRoleOptionsV07.cs"/>
 212 ····<Compile·Include="AmongUs\GameOptions\EngineerRoleOptionsV08.cs"/>
194 ····<Compile·Include="AmongUs\GameOptions\FloatArrayOptionNames.cs"/>213 ····<Compile·Include="AmongUs\GameOptions\FloatArrayOptionNames.cs"/>
195 ····<Compile·Include="AmongUs\GameOptions\FloatOptionNames.cs"/>214 ····<Compile·Include="AmongUs\GameOptions\FloatOptionNames.cs"/>
196 ····<Compile·Include="AmongUs\GameOptions\GameKeywords.cs"/>215 ····<Compile·Include="AmongUs\GameOptions\GameKeywords.cs"/>
197 ····<Compile·Include="AmongUs\GameOptions\GameModes.cs"/>216 ····<Compile·Include="AmongUs\GameOptions\GameModes.cs"/>
198 ····<Compile·Include="AmongUs\GameOptions\GameOptionsData.cs"/>217 ····<Compile·Include="AmongUs\GameOptions\GameOptionsData.cs"/>
199 ····<Compile·Include="AmongUs\GameOptions\GameOptionsFactory.cs"/>218 ····<Compile·Include="AmongUs\GameOptions\GameOptionsFactory.cs"/>
200 ····<Compile·Include="AmongUs\GameOptions\GameOptionsMigratorV06toV07.cs"/>219 ····<Compile·Include="AmongUs\GameOptions\GameOptionsMigratorV06toV07.cs"/>
 220 ····<Compile·Include="AmongUs\GameOptions\GameOptionsMigratorV07toV08.cs"/>
201 ····<Compile·Include="AmongUs\GameOptions\GuardianAngelRoleOptionsV07.cs"/>221 ····<Compile·Include="AmongUs\GameOptions\GuardianAngelRoleOptionsV07.cs"/>
 222 ····<Compile·Include="AmongUs\GameOptions\GuardianAngelRoleOptionsV08.cs"/>
202 ····<Compile·Include="AmongUs\GameOptions\HideNSeekGameOptionsV07.cs"/>223 ····<Compile·Include="AmongUs\GameOptions\HideNSeekGameOptionsV07.cs"/>
 224 ····<Compile·Include="AmongUs\GameOptions\HideNSeekGameOptionsV08.cs"/>
203 ····<Compile·Include="AmongUs\GameOptions\IGameOptions.cs"/>225 ····<Compile·Include="AmongUs\GameOptions\IGameOptions.cs"/>
204 ····<Compile·Include="AmongUs\GameOptions\IGameOptionsMigrator.cs"/>226 ····<Compile·Include="AmongUs\GameOptions\IGameOptionsMigrator.cs"/>
205 ····<Compile·Include="AmongUs\GameOptions\Int32ArrayOptionNames.cs"/>227 ····<Compile·Include="AmongUs\GameOptions\Int32ArrayOptionNames.cs"/>
206 ····<Compile·Include="AmongUs\GameOptions\Int32OptionNames.cs"/>228 ····<Compile·Include="AmongUs\GameOptions\Int32OptionNames.cs"/>
207 ····<Compile·Include="AmongUs\GameOptions\IRoleOptions.cs"/>229 ····<Compile·Include="AmongUs\GameOptions\IRoleOptions.cs"/>
208 ····<Compile·Include="AmongUs\GameOptions\IRoleOptionsCollection.cs"/>230 ····<Compile·Include="AmongUs\GameOptions\IRoleOptionsCollection.cs"/>
 231 ····<Compile·Include="AmongUs\GameOptions\NoisemakerRoleOptionsV08.cs"/>
209 ····<Compile·Include="AmongUs\GameOptions\NormalGameOptionsV07.cs"/>232 ····<Compile·Include="AmongUs\GameOptions\NormalGameOptionsV07.cs"/>
 233 ····<Compile·Include="AmongUs\GameOptions\NormalGameOptionsV08.cs"/>
 234 ····<Compile·Include="AmongUs\GameOptions\PhantomRoleOptionsV08.cs"/>
210 ····<Compile·Include="AmongUs\GameOptions\RoleDataV07.cs"/>235 ····<Compile·Include="AmongUs\GameOptions\RoleDataV07.cs"/>
 236 ····<Compile·Include="AmongUs\GameOptions\RoleDataV08.cs"/>
211 ····<Compile·Include="AmongUs\GameOptions\RoleOptionsCollectionV07.cs"/>237 ····<Compile·Include="AmongUs\GameOptions\RoleOptionsCollectionV07.cs"/>
 238 ····<Compile·Include="AmongUs\GameOptions\RoleOptionsCollectionV08.cs"/>
212 ····<Compile·Include="AmongUs\GameOptions\RoleOptionsData.cs"/>239 ····<Compile·Include="AmongUs\GameOptions\RoleOptionsData.cs"/>
213 ····<Compile·Include="AmongUs\GameOptions\RoleRate.cs"/>240 ····<Compile·Include="AmongUs\GameOptions\RoleRate.cs"/>
214 ····<Compile·Include="AmongUs\GameOptions\RoleTypes.cs"/>241 ····<Compile·Include="AmongUs\GameOptions\RoleTypes.cs"/>
 242 ····<Compile·Include="AmongUs\GameOptions\RulesPresets.cs"/>
215 ····<Compile·Include="AmongUs\GameOptions\ScientistRoleOptionsV07.cs"/>243 ····<Compile·Include="AmongUs\GameOptions\ScientistRoleOptionsV07.cs"/>
 244 ····<Compile·Include="AmongUs\GameOptions\ScientistRoleOptionsV08.cs"/>
216 ····<Compile·Include="AmongUs\GameOptions\ShapeshifterRoleOptionsV07.cs"/>245 ····<Compile·Include="AmongUs\GameOptions\ShapeshifterRoleOptionsV07.cs"/>
 246 ····<Compile·Include="AmongUs\GameOptions\ShapeshifterRoleOptionsV08.cs"/>
 247 ····<Compile·Include="AmongUs\GameOptions\SpecialGameModes.cs"/>
217 ····<Compile·Include="AmongUs\GameOptions\TaskBarMode.cs"/>248 ····<Compile·Include="AmongUs\GameOptions\TaskBarMode.cs"/>
 249 ····<Compile·Include="AmongUs\GameOptions\TrackerRoleOptionsV08.cs"/>
218 ····<Compile·Include="AmongUs\GameOptions\UInt32OptionNames.cs"/>250 ····<Compile·Include="AmongUs\GameOptions\UInt32OptionNames.cs"/>
219 ····<Compile·Include="AmongUs\HTTP\RetryableWebRequest.cs"/>251 ····<Compile·Include="AmongUs\HTTP\RetryableWebRequest.cs"/>
220 ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPage.cs"/>252 ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPage.cs"/>
221 ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPhrasesPageButton.cs"/>253 ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatMenuPhrasesPageButton.cs"/>
222 ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatPhraseRuleGroup.cs"/>254 ····<Compile·Include="AmongUs\QuickChat\AbstractQuickChatPhraseRuleGroup.cs"/>
223 ····<Compile·Include="AmongUs\QuickChat\IQuickChatPhraseCollector.cs"/>255 ····<Compile·Include="AmongUs\QuickChat\IQuickChatPhraseCollector.cs"/>
224 ····<Compile·Include="AmongUs\QuickChat\QuickChatBreadcrumb.cs"/>256 ····<Compile·Include="AmongUs\QuickChat\QuickChatBreadcrumb.cs"/>
Offset 322, 14 lines modifiedOffset 354, 15 lines modified
322 ····<Compile·Include="AutoScroll.cs"/>354 ····<Compile·Include="AutoScroll.cs"/>
323 ····<Compile·Include="AutoTaskConsole.cs"/>355 ····<Compile·Include="AutoTaskConsole.cs"/>
324 ····<Compile·Include="AxisDirection.cs"/>356 ····<Compile·Include="AxisDirection.cs"/>
325 ····<Compile·Include="BackendEndpoints.cs"/>357 ····<Compile·Include="BackendEndpoints.cs"/>
326 ····<Compile·Include="BalloonBehaviour.cs"/>358 ····<Compile·Include="BalloonBehaviour.cs"/>
327 ····<Compile·Include="BanButton.cs"/>359 ····<Compile·Include="BanButton.cs"/>
328 ····<Compile·Include="BanMenu.cs"/>360 ····<Compile·Include="BanMenu.cs"/>
 361 ····<Compile·Include="BaseGameSetting.cs"/>
329 ····<Compile·Include="BlockedPlayerBar.cs"/>362 ····<Compile·Include="BlockedPlayerBar.cs"/>
330 ····<Compile·Include="BlockedWords.cs"/>363 ····<Compile·Include="BlockedWords.cs"/>
Max diff block lines reached; 18249/26508 bytes (68.84%) of diff not shown.
921 B
Assembly-CSharp/BanMenu.cs
    
Offset 7, 15 lines modifiedOffset 7, 15 lines modified
7 public·class·BanMenu·:·MonoBehaviour7 public·class·BanMenu·:·MonoBehaviour
8 {8 {
9 »       public·void·SetVisible(bool·show)9 »       public·void·SetVisible(bool·show)
10 »       {10 »       {
11 »       »       bool·flag;11 »       »       bool·flag;
12 »       »       if·(PlayerControl.LocalPlayer)12 »       »       if·(PlayerControl.LocalPlayer)
13 »       »       {13 »       »       {
14 »       »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;14 »       »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
15 »       »       »       flag·=·data·!=·null·&&·!data.IsDead;15 »       »       »       flag·=·data·!=·null·&&·!data.IsDead;
16 »       »       }16 »       »       }
17 »       »       else17 »       »       else
18 »       »       {18 »       »       {
19 »       »       »       flag·=·false;19 »       »       »       flag·=·false;
20 »       »       }20 »       »       }
21 »       »       bool·flag2·=·flag;21 »       »       bool·flag2·=·flag;
Offset 248, 16 lines modifiedOffset 248, 16 lines modified
248 248
249 »       public·int·selectedClientId·=·-1;249 »       public·int·selectedClientId·=·-1;
250 250
251 »       public·List<BanButton>·allButtons·=·new·List<BanButton>();251 »       public·List<BanButton>·allButtons·=·new·List<BanButton>();
252 252
253 »       private·List<ClientData>·recentClients·=·new·List<ClientData>();253 »       private·List<ClientData>·recentClients·=·new·List<ClientData>();
254 254
255 »       [Header("Alignment·Settings")] 
256 »       [SerializeField]255 »       [SerializeField]
 256 »       [Header("Alignment·Settings")]
257 »       private·float·backgroundTailWidth·=·0.4f;257 »       private·float·backgroundTailWidth·=·0.4f;
258 258
259 »       [SerializeField]259 »       [SerializeField]
260 »       private·float·backgroundBaseWidth·=·3.2f;260 »       private·float·backgroundBaseWidth·=·3.2f;
261 261
262 »       [SerializeField]262 »       [SerializeField]
263 »       private·float·backgroundBaseHeight·=·1.2f;263 »       private·float·backgroundBaseHeight·=·1.2f;
919 B
Assembly-CSharp/BugReportPopup.cs
Ordering differences only
    
Offset 108, 16 lines modifiedOffset 108, 16 lines modified
108 »       »       {108 »       »       {
109 »       »       »       this.descriptionCharacterCount.color·=·new·Color(1f,·1f,·0f,·1f);109 »       »       »       this.descriptionCharacterCount.color·=·new·Color(1f,·1f,·0f,·1f);
110 »       »       »       return;110 »       »       »       return;
111 »       »       }111 »       »       }
112 »       »       this.descriptionCharacterCount.color·=·Color.red;112 »       »       this.descriptionCharacterCount.color·=·Color.red;
113 »       }113 »       }
114 114
115 »       [SerializeField] 
116 »       [Header("Buttons")]115 »       [Header("Buttons")]
 116 »       [SerializeField]
117 »       private·PassiveButton[]·closeButtons;117 »       private·PassiveButton[]·closeButtons;
118 118
119 »       [SerializeField]119 »       [SerializeField]
120 »       private·PassiveButton·submitButton;120 »       private·PassiveButton·submitButton;
121 121
122 »       [Header("Form")]122 »       [Header("Form")]
123 »       [SerializeField]123 »       [SerializeField]
Offset 128, 16 lines modifiedOffset 128, 16 lines modified
128 128
129 »       [SerializeField]129 »       [SerializeField]
130 »       private·PassiveButton·descriptionFieldButton;130 »       private·PassiveButton·descriptionFieldButton;
131 131
132 »       [SerializeField]132 »       [SerializeField]
133 »       private·Checkbox·attachScreenshotCheckbox;133 »       private·Checkbox·attachScreenshotCheckbox;
134 134
135 »       [Header("Feedback·&·Validation")] 
136 »       [SerializeField]135 »       [SerializeField]
 136 »       [Header("Feedback·&·Validation")]
137 »       private·TextMeshPro·descriptionCharacterCount;137 »       private·TextMeshPro·descriptionCharacterCount;
138 138
139 »       [SerializeField]139 »       [SerializeField]
140 »       private·TextMeshPro·submittedText;140 »       private·TextMeshPro·submittedText;
141 141
142 »       [SerializeField]142 »       [SerializeField]
143 »       [Header("Console·Controller·Navigation")]143 »       [Header("Console·Controller·Navigation")]
1.24 KB
Assembly-CSharp/BuildSandcastleMinigame.cs
Ordering differences only
    
Offset 109, 32 lines modifiedOffset 109, 32 lines modified
109 »       »       {109 »       »       {
110 »       »       »       SoundManager.Instance.PlaySound(this.completeSound,·false,·1f,·null);110 »       »       »       SoundManager.Instance.PlaySound(this.completeSound,·false,·1f,·null);
111 »       »       }111 »       »       }
112 »       }112 »       }
113 113
114 »       private·const·float·CLOSE_ENOUGH_TO_TOP·=·0.8f;114 »       private·const·float·CLOSE_ENOUGH_TO_TOP·=·0.8f;
115 115
116 »       [Tooltip("The·speed·at·which·lifting·with·an·analog·stick·moves·towards·the·true·lift·value.")] 
117 »       [SerializeField] 
118 »       [Header("Timing")]116 »       [Header("Timing")]
 117 »       [SerializeField]
 118 »       [Tooltip("The·speed·at·which·lifting·with·an·analog·stick·moves·towards·the·true·lift·value.")]
119 »       private·float·liftLerpSpeed·=·5f;119 »       private·float·liftLerpSpeed·=·5f;
120 120
121 »       [Tooltip("The·acceleration·at·which·the·bucket·falls·back·down,·per·second.·(Added·to·fallVelocity·per·second)")] 
122 »       [SerializeField]121 »       [SerializeField]
 122 »       [Tooltip("The·acceleration·at·which·the·bucket·falls·back·down,·per·second.·(Added·to·fallVelocity·per·second)")]
123 »       private·float·fallGravity·=·0.5f;123 »       private·float·fallGravity·=·0.5f;
124 124
125 »       [SerializeField] 
126 »       [Header("Lift·Range")]125 »       [Header("Lift·Range")]
 126 »       [SerializeField]
127 »       private·Transform·startPosition;127 »       private·Transform·startPosition;
128 128
129 »       [SerializeField]129 »       [SerializeField]
130 »       private·Transform·endPosition;130 »       private·Transform·endPosition;
131 131
132 »       [Header("Bucket")] 
133 »       [SerializeField]132 »       [SerializeField]
 133 »       [Header("Bucket")]
134 »       private·Collider2D·bucketCollider;134 »       private·Collider2D·bucketCollider;
135 135
136 »       [SerializeField]136 »       [SerializeField]
137 »       private·SpriteRenderer·bucketSprite;137 »       private·SpriteRenderer·bucketSprite;
138 138
139 »       [SerializeField]139 »       [SerializeField]
140 »       private·SpriteRenderer·bucketBackSprite;140 »       private·SpriteRenderer·bucketBackSprite;
636 B
Assembly-CSharp/BundleData.cs
    
Offset 35, 15 lines modifiedOffset 35, 15 lines modified
35 »       »       }35 »       »       }
36 »       }36 »       }
37 37
38 »       public·LimitedTimeStartEnd·LimitedTimeAvailable38 »       public·LimitedTimeStartEnd·LimitedTimeAvailable
39 »       {39 »       {
40 »       »       get40 »       »       get
41 »       »       {41 »       »       {
42 »       »       »       return·default(LimitedTimeStartEnd);42 »       »       »       return·this.limitedTime;
43 »       »       }43 »       »       }
44 »       }44 »       }
45 45
46 »       public·string·GetItemName()46 »       public·string·GetItemName()
47 »       {47 »       {
48 »       »       return·DestroyableSingleton<TranslationController>.Instance.GetString("Bundle."·+·this.productId,·this.productId,·Array.Empty<object>());48 »       »       return·DestroyableSingleton<TranslationController>.Instance.GetString("Bundle."·+·this.productId,·this.productId,·Array.Empty<object>());
49 »       }49 »       }
Offset 81, 8 lines modifiedOffset 81, 11 lines modified
81 »       public·Sprite·StoreImage;81 »       public·Sprite·StoreImage;
82 82
83 »       public·bool·NotInStore;83 »       public·bool·NotInStore;
84 84
85 »       public·bool·Free;85 »       public·bool·Free;
86 86
87 »       public·bool·paidOnMobile;87 »       public·bool·paidOnMobile;
 88
 89 »       [SerializeField]
 90 »       private·LimitedTimeStartEnd·limitedTime;
88 }91 }
863 B
Assembly-CSharp/CatchFishMinigame.cs
Ordering differences only
    
Offset 241, 16 lines modifiedOffset 241, 16 lines modified
241 241
242 »       private·const·float·SECONDS_TO_WAIT_FOR_FISH_TO_BE_CAUGHT·=·5f;242 »       private·const·float·SECONDS_TO_WAIT_FOR_FISH_TO_BE_CAUGHT·=·5f;
243 243
244 »       private·const·float·LIGHTLY_BOBBING·=·0.02f;244 »       private·const·float·LIGHTLY_BOBBING·=·0.02f;
245 245
246 »       private·const·float·STRONGLY_BOBBING·=·0.1f;246 »       private·const·float·STRONGLY_BOBBING·=·0.1f;
247 247
248 »       [Header("Fishing·Rod")] 
249 »       [SerializeField]248 »       [SerializeField]
 249 »       [Header("Fishing·Rod")]
250 »       private·Transform·fishingRod;250 »       private·Transform·fishingRod;
251 251
252 »       [SerializeField]252 »       [SerializeField]
253 »       private·SpriteRenderer·fishingLine;253 »       private·SpriteRenderer·fishingLine;
254 254
255 »       [SerializeField]255 »       [SerializeField]
256 »       private·Vector3·rodPutAwayPosition;256 »       private·Vector3·rodPutAwayPosition;
Offset 289, 16 lines modifiedOffset 289, 16 lines modified
289 289
290 »       [SerializeField]290 »       [SerializeField]
291 »       private·Transform·alert;291 »       private·Transform·alert;
292 292
293 »       [SerializeField]293 »       [SerializeField]
294 »       private·float·caughtFishScale;294 »       private·float·caughtFishScale;
295 295
296 »       [Header("Audio")] 
297 »       [SerializeField]296 »       [SerializeField]
 297 »       [Header("Audio")]
298 »       private·AudioClip·onHookSfx;298 »       private·AudioClip·onHookSfx;
299 299
300 »       [SerializeField]300 »       [SerializeField]
301 »       private·AudioClip·onMissSfx;301 »       private·AudioClip·onMissSfx;
302 302
303 »       [SerializeField]303 »       [SerializeField]
304 »       private·AudioClip·onCatchSfx;304 »       private·AudioClip·onCatchSfx;
1020 B
Assembly-CSharp/ChatBubble.cs
    
Offset 50, 15 lines modifiedOffset 50, 15 lines modified
50 »       »       this.TextArea.color·=·Color.red;50 »       »       this.TextArea.color·=·Color.red;
51 »       »       this.SetText(text);51 »       »       this.SetText(text);
52 »       »       this.TextArea.rectTransform.pivot·=·new·Vector2(0f,·0f);52 »       »       this.TextArea.rectTransform.pivot·=·new·Vector2(0f,·0f);
53 »       »       this.TextArea.transform.localPosition·=·new·Vector3(-0.25f,·-0.15f,·0f);53 »       »       this.TextArea.transform.localPosition·=·new·Vector3(-0.25f,·-0.15f,·0f);
54 »       »       this.TextArea.horizontalAlignment·=·HorizontalAlignmentOptions.Left;54 »       »       this.TextArea.horizontalAlignment·=·HorizontalAlignmentOptions.Left;
55 »       }55 »       }
56 56
57 »       public·void·SetCosmetics(GameData.PlayerInfo·playerInfo)57 »       public·void·SetCosmetics(NetworkedPlayerInfo·playerInfo)
58 »       {58 »       {
59 »       »       this.playerInfo·=·playerInfo;59 »       »       this.playerInfo·=·playerInfo;
60 »       »       if·(base.gameObject.activeInHierarchy)60 »       »       if·(base.gameObject.activeInHierarchy)
61 »       »       {61 »       »       {
62 »       »       »       this.Player.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null);62 »       »       »       this.Player.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null);
63 »       »       }63 »       »       }
64 »       »       this.Player.ToggleName(false);64 »       »       this.Player.ToggleName(false);
Offset 179, 11 lines modifiedOffset 179, 11 lines modified
179 179
180 »       public·SpriteRenderer·MaskArea;180 »       public·SpriteRenderer·MaskArea;
181 181
182 »       public·PlatformIdentifier·PlatformIcon;182 »       public·PlatformIdentifier·PlatformIcon;
183 183
184 »       public·TextMeshPro·ColorBlindName;184 »       public·TextMeshPro·ColorBlindName;
185 185
186 »       private·GameData.PlayerInfo·playerInfo;186 »       private·NetworkedPlayerInfo·playerInfo;
187 187
188 »       private·int·maskLayer;188 »       private·int·maskLayer;
189 }189 }
7.75 KB
Assembly-CSharp/ChatController.cs
    
Offset 193, 14 lines modifiedOffset 193, 15 lines modified
193 »       »       base.StopAllCoroutines();193 »       »       base.StopAllCoroutines();
194 »       »       this.quickChatMenu.CloseImmediately();194 »       »       this.quickChatMenu.CloseImmediately();
195 »       »       this.freeChatField.Unfocus();195 »       »       this.freeChatField.Unfocus();
196 »       »       this.chatScreen.SetActive(false);196 »       »       this.chatScreen.SetActive(false);
197 »       »       this.banButton.SetVisible(false);197 »       »       this.banButton.SetVisible(false);
198 »       »       this.banButton.Hide();198 »       »       this.banButton.Hide();
199 »       »       this.state·=·ChatControllerState.Closed;199 »       »       this.state·=·ChatControllerState.Closed;
 200 »       »       this.chatButton.SelectButton(false);
200 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)201 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
201 »       »       {202 »       »       {
202 »       »       »       DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true);203 »       »       »       DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true);
203 »       »       }204 »       »       }
204 »       »       if·(DestroyableSingleton<GameStartManager>.InstanceExists)205 »       »       if·(DestroyableSingleton<GameStartManager>.InstanceExists)
205 »       »       {206 »       »       {
206 »       »       »       DestroyableSingleton<GameStartManager>.Instance.ToggleButtonGlyphs(true);207 »       »       »       DestroyableSingleton<GameStartManager>.Instance.ToggleButtonGlyphs(true);
Offset 212, 14 lines modifiedOffset 213, 18 lines modified
212 »       public·void·Toggle()213 »       public·void·Toggle()
213 »       {214 »       {
214 »       »       CustomNetworkTransform·customNetworkTransform·=·(PlayerControl.LocalPlayer·?·PlayerControl.LocalPlayer.NetTransform·:·null);215 »       »       CustomNetworkTransform·customNetworkTransform·=·(PlayerControl.LocalPlayer·?·PlayerControl.LocalPlayer.NetTransform·:·null);
215 »       »       if·(!customNetworkTransform·||·DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.activeSelf)216 »       »       if·(!customNetworkTransform·||·DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.activeSelf)
216 »       »       {217 »       »       {
217 »       »       »       return;218 »       »       »       return;
218 »       »       }219 »       »       }
 220 »       »       if·(PlayerCustomizationMenu.Instance·&&·PlayerCustomizationMenu.Instance.cosmicubeMenu.activeSelf)
 221 »       »       {
 222 »       »       »       return;
 223 »       »       }
219 »       »       base.StopAllCoroutines();224 »       »       base.StopAllCoroutines();
220 »       »       if·(this.IsOpenOrOpening)225 »       »       if·(this.IsOpenOrOpening)
221 »       »       {226 »       »       {
222 »       »       »       base.StartCoroutine(this.CoClose());227 »       »       »       base.StartCoroutine(this.CoClose());
223 »       »       »       if·(DestroyableSingleton<FriendsListManager>.InstanceExists)228 »       »       »       if·(DestroyableSingleton<FriendsListManager>.InstanceExists)
224 »       »       »       {229 »       »       »       {
225 »       »       »       »       DestroyableSingleton<FriendsListManager>.Instance.SetFriendButtonColor(false);230 »       »       »       »       DestroyableSingleton<FriendsListManager>.Instance.SetFriendButtonColor(false);
Offset 250, 14 lines modifiedOffset 255, 15 lines modified
250 255
251 »       private·IEnumerator·CoOpen()256 »       private·IEnumerator·CoOpen()
252 »       {257 »       {
253 »       »       this.CheckKeyboardButton();258 »       »       this.CheckKeyboardButton();
254 »       »       this.state·=·ChatControllerState.Opening;259 »       »       this.state·=·ChatControllerState.Opening;
255 »       »       float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationIn.keys).time;260 »       »       float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationIn.keys).time;
256 »       »       this.chatButtonAspectPosition.AdjustPosition();261 »       »       this.chatButtonAspectPosition.AdjustPosition();
 262 »       »       this.chatButton.SelectButton(true);
257 »       »       this.quickChatMenu.Clear();263 »       »       this.quickChatMenu.Clear();
258 »       »       this.quickChatField.Clear();264 »       »       this.quickChatField.Clear();
259 »       »       this.quickChatMenu.Close();265 »       »       this.quickChatMenu.Close();
260 »       »       this.banButton.Hide();266 »       »       this.banButton.Hide();
261 »       »       this.banButton.SetVisible(true);267 »       »       this.banButton.SetVisible(true);
262 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)268 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
263 »       »       {269 »       »       {
Offset 290, 14 lines modifiedOffset 296, 15 lines modified
290 »       »       yield·break;296 »       »       yield·break;
291 »       }297 »       }
292 298
293 »       private·IEnumerator·CoClose()299 »       private·IEnumerator·CoClose()
294 »       {300 »       {
295 »       »       this.state·=·ChatControllerState.Closing;301 »       »       this.state·=·ChatControllerState.Closing;
296 »       »       float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationOut.keys).time;302 »       »       float·duration·=·Enumerable.Last<Keyframe>(this.chatAnimationOut.keys).time;
 303 »       »       this.chatButton.SelectButton(false);
297 »       »       this.quickChatMenu.Close();304 »       »       this.quickChatMenu.Close();
298 »       »       this.banButton.Hide();305 »       »       this.banButton.Hide();
299 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)306 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
300 »       »       {307 »       »       {
301 »       »       »       DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true);308 »       »       »       DestroyableSingleton<HudManager>.Instance.ToggleMapButtonGlyph(true);
302 »       »       }309 »       »       }
303 »       »       if·(DestroyableSingleton<GameStartManager>.InstanceExists)310 »       »       if·(DestroyableSingleton<GameStartManager>.InstanceExists)
Offset 322, 15 lines modifiedOffset 329, 15 lines modified
322 »       »       ConsoleJoystick.SetMode_Menu();329 »       »       ConsoleJoystick.SetMode_Menu();
323 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);330 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);
324 »       »       this.state·=·ChatControllerState.Closed;331 »       »       this.state·=·ChatControllerState.Closed;
325 »       »       this.freeChatField.ForceKeyboardClose();332 »       »       this.freeChatField.ForceKeyboardClose();
326 »       »       yield·break;333 »       »       yield·break;
327 »       }334 »       }
328 335
329 »       public·void·AddChatNote(GameData.PlayerInfo·srcPlayer,·ChatNoteTypes·noteType)336 »       public·void·AddChatNote(NetworkedPlayerInfo·srcPlayer,·ChatNoteTypes·noteType)
330 »       {337 »       {
331 »       »       if·(srcPlayer·==·null)338 »       »       if·(srcPlayer·==·null)
332 »       »       {339 »       »       {
333 »       »       »       return;340 »       »       »       return;
334 »       »       }341 »       »       }
335 »       »       ChatBubble·pooledBubble·=·this.GetPooledBubble();342 »       »       ChatBubble·pooledBubble·=·this.GetPooledBubble();
336 »       »       pooledBubble.SetCosmetics(srcPlayer);343 »       »       pooledBubble.SetCosmetics(srcPlayer);
Offset 357, 16 lines modifiedOffset 364, 16 lines modified
357 364
358 »       public·void·AddChat(PlayerControl·sourcePlayer,·string·chatText,·bool·censor·=·true)365 »       public·void·AddChat(PlayerControl·sourcePlayer,·string·chatText,·bool·censor·=·true)
359 »       {366 »       {
360 »       »       if·(!sourcePlayer·||·!PlayerControl.LocalPlayer)367 »       »       if·(!sourcePlayer·||·!PlayerControl.LocalPlayer)
361 »       »       {368 »       »       {
362 »       »       »       return;369 »       »       »       return;
363 »       »       }370 »       »       }
364 »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;371 »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
365 »       »       GameData.PlayerInfo·data2·=·sourcePlayer.Data;372 »       »       NetworkedPlayerInfo·data2·=·sourcePlayer.Data;
366 »       »       if·(data2·==·null·||·data·==·null·||·(data2.IsDead·&&·!data.IsDead))373 »       »       if·(data2·==·null·||·data·==·null·||·(data2.IsDead·&&·!data.IsDead))
367 »       »       {374 »       »       {
368 »       »       »       return;375 »       »       »       return;
369 »       »       }376 »       »       }
370 »       »       ChatBubble·pooledBubble·=·this.GetPooledBubble();377 »       »       ChatBubble·pooledBubble·=·this.GetPooledBubble();
371 »       »       try378 »       »       try
372 »       »       {379 »       »       {
Offset 394, 14 lines modifiedOffset 401, 15 lines modified
394 »       »       »       if·(!this.IsOpenOrOpening·&&·this.notificationRoutine·==·null)401 »       »       »       if·(!this.IsOpenOrOpening·&&·this.notificationRoutine·==·null)
395 »       »       »       {402 »       »       »       {
396 »       »       »       »       this.notificationRoutine·=·base.StartCoroutine(this.BounceDot());403 »       »       »       »       this.notificationRoutine·=·base.StartCoroutine(this.BounceDot());
397 »       »       »       }404 »       »       »       }
398 »       »       »       if·(!flag)405 »       »       »       if·(!flag)
399 »       »       »       {406 »       »       »       {
400 »       »       »       »       SoundManager.Instance.PlaySound(this.messageSound,·false,·1f,·null).pitch·=·0.5f·+·(float)sourcePlayer.PlayerId·/·15f;407 »       »       »       »       SoundManager.Instance.PlaySound(this.messageSound,·false,·1f,·null).pitch·=·0.5f·+·(float)sourcePlayer.PlayerId·/·15f;
 408 »       »       »       »       this.chatNotification.SetUp(sourcePlayer,·chatText);
401 »       »       »       }409 »       »       »       }
402 »       »       }410 »       »       }
403 »       »       catch·(Exception·ex)411 »       »       catch·(Exception·ex)
404 »       »       {412 »       »       {
405 »       »       »       ChatController.Logger.Error(ex,·null);413 »       »       »       ChatController.Logger.Error(ex,·null);
406 »       »       »       this.chatBubblePool.Reclaim(pooledBubble);414 »       »       »       this.chatBubblePool.Reclaim(pooledBubble);
407 »       »       }415 »       »       }
Offset 427, 33 lines modifiedOffset 435, 33 lines modified
427 »       »       catch·(Exception·ex)435 »       »       catch·(Exception·ex)
428 »       »       {436 »       »       {
429 »       »       »       ChatController.Logger.Error(ex,·null);437 »       »       »       ChatController.Logger.Error(ex,·null);
430 »       »       »       this.chatBubblePool.Reclaim(pooledBubble);438 »       »       »       this.chatBubblePool.Reclaim(pooledBubble);
431 »       »       }439 »       »       }
432 »       }440 »       }
433 441
434 »       private·void·SetChatBubbleName(ChatBubble·bubble,·GameData.PlayerInfo·playerInfo,·bool·isDead,·bool·didVote,·Color·nameColor,·ChatController.GetFormattedNameFunc·getFormattedNameFunc·=·null)442 »       private·void·SetChatBubbleName(ChatBubble·bubble,·NetworkedPlayerInfo·playerInfo,·bool·isDead,·bool·didVote,·Color·nameColor,·ChatController.GetFormattedNameFunc·getFormattedNameFunc·=·null)
435 »       {443 »       {
436 »       »       if·(!string.IsNullOrEmpty(playerInfo.PlayerName))444 »       »       if·(!string.IsNullOrEmpty(playerInfo.PlayerName))
437 »       »       {445 »       »       {
Max diff block lines reached; 3090/7865 bytes (39.29%) of diff not shown.
783 B
Assembly-CSharp/CollectableVegetable.cs
Ordering differences only
    
Offset 266, 29 lines modifiedOffset 266, 29 lines modified
266 266
267 »       [SerializeField]267 »       [SerializeField]
268 »       private·GameObject·chard;268 »       private·GameObject·chard;
269 269
270 »       [SerializeField]270 »       [SerializeField]
271 »       private·GameObject·curls;271 »       private·GameObject·curls;
272 272
273 »       [Header("Navigation")] 
274 »       [SerializeField]273 »       [SerializeField]
 274 »       [Header("Navigation")]
275 »       private·CollectableVegetable·neighborUp;275 »       private·CollectableVegetable·neighborUp;
276 276
277 »       [SerializeField]277 »       [SerializeField]
278 »       private·CollectableVegetable·neighborDown;278 »       private·CollectableVegetable·neighborDown;
279 279
280 »       [SerializeField]280 »       [SerializeField]
281 »       private·CollectableVegetable·neighborLeft;281 »       private·CollectableVegetable·neighborLeft;
282 282
283 »       [SerializeField]283 »       [SerializeField]
284 »       private·CollectableVegetable·neighborRight;284 »       private·CollectableVegetable·neighborRight;
285 285
286 »       [Header("Visuals")] 
287 »       [SerializeField]286 »       [SerializeField]
 287 »       [Header("Visuals")]
288 »       private·GameObject·vegetableContainer;288 »       private·GameObject·vegetableContainer;
289 289
290 »       [SerializeField]290 »       [SerializeField]
291 »       private·Collider2D·collider;291 »       private·Collider2D·collider;
292 292
293 »       [SerializeField]293 »       [SerializeField]
294 »       private·GameObject·selectionGlyph;294 »       private·GameObject·selectionGlyph;
519 B
Assembly-CSharp/CollectShellsMinigame.cs
Ordering differences only
    
Offset 153, 16 lines modifiedOffset 153, 16 lines modified
153 153
154 »       [SerializeField]154 »       [SerializeField]
155 »       private·GameObject·controllerCursor;155 »       private·GameObject·controllerCursor;
156 156
157 »       [SerializeField]157 »       [SerializeField]
158 »       private·GameObject·handWipeObject;158 »       private·GameObject·handWipeObject;
159 159
160 »       [Header("Audio")] 
161 »       [SerializeField]160 »       [SerializeField]
 161 »       [Header("Audio")]
162 »       private·AudioClip[]·dustSounds;162 »       private·AudioClip[]·dustSounds;
163 163
164 »       private·List<CollectableShell>·shells·=·new·List<CollectableShell>();164 »       private·List<CollectableShell>·shells·=·new·List<CollectableShell>();
165 165
166 »       private·Controller·controller·=·new·Controller();166 »       private·Controller·controller·=·new·Controller();
167 167
168 »       private·Vector2·prevMousePos;168 »       private·Vector2·prevMousePos;
613 B
Assembly-CSharp/CollectVegetablesMinigame.cs
Ordering differences only
    
Offset 71, 20 lines modifiedOffset 71, 20 lines modified
71 »       »       »       yield·return·Effects.Wait(0.5f);71 »       »       »       yield·return·Effects.Wait(0.5f);
72 »       »       »       base.transform.parent.GetComponent<MultistageMinigame>().Close();72 »       »       »       base.transform.parent.GetComponent<MultistageMinigame>().Close();
73 »       »       }73 »       »       }
74 »       »       yield·return·null;74 »       »       yield·return·null;
75 »       »       yield·break;75 »       »       yield·break;
76 »       }76 »       }
77 77
78 »       [SerializeField] 
79 »       [Header("Design")]78 »       [Header("Design")]
 79 »       [SerializeField]
80 »       private·float·navigationDelay·=·0.2f;80 »       private·float·navigationDelay·=·0.2f;
81 81
82 »       [SerializeField] 
83 »       [Header("Components")]82 »       [Header("Components")]
 83 »       [SerializeField]
84 »       private·CollectableVegetable[]·collectables;84 »       private·CollectableVegetable[]·collectables;
85 85
86 »       [SerializeField]86 »       [SerializeField]
87 »       private·AudioClip·selectionChangedSfx;87 »       private·AudioClip·selectionChangedSfx;
88 88
89 »       private·int·selection;89 »       private·int·selection;
90 90
970 B
Assembly-CSharp/Console.cs
    
Offset 34, 15 lines modifiedOffset 34, 15 lines modified
34 »       »       {34 »       »       {
35 »       »       »       this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));35 »       »       »       this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));
36 »       »       »       this.Image.material.SetColor("_OutlineColor",·Color.yellow);36 »       »       »       this.Image.material.SetColor("_OutlineColor",·Color.yellow);
37 »       »       »       this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.yellow·:·Color.clear);37 »       »       »       this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.yellow·:·Color.clear);
38 »       »       }38 »       »       }
39 »       }39 »       }
40 40
41 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)41 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
42 »       {42 »       {
43 »       »       float·num·=·float.MaxValue;43 »       »       float·num·=·float.MaxValue;
44 »       »       PlayerControl·@object·=·pc.Object;44 »       »       PlayerControl·@object·=·pc.Object;
45 »       »       Vector2·truePosition·=·@object.GetTruePosition();45 »       »       Vector2·truePosition·=·@object.GetTruePosition();
46 »       »       Vector3·position·=·base.transform.position;46 »       »       Vector3·position·=·base.transform.position;
47 »       »       couldUse·=·(!pc.IsDead·||·(GameManager.Instance.LogicOptions.GetGhostsDoTasks()·&&·!this.GhostsIgnored))·&&·@object.CanMove·&&·pc.Role.CanUse(this)·&&·(!this.onlySameRoom·||·this.InRoom(truePosition))·&&·(!this.onlyFromBelow·||·truePosition.y·<·position.y)·&&·this.FindTask(@object);47 »       »       couldUse·=·(!pc.IsDead·||·(GameManager.Instance.LogicOptions.GetGhostsDoTasks()·&&·!this.GhostsIgnored))·&&·@object.CanMove·&&·pc.Role.CanUse(this)·&&·(!this.onlySameRoom·||·this.InRoom(truePosition))·&&·(!this.onlyFromBelow·||·truePosition.y·<·position.y)·&&·this.FindTask(@object);
48 »       »       canUse·=·couldUse;48 »       »       canUse·=·couldUse;
1.4 KB
Assembly-CSharp/Constants.cs
    
Offset 17, 15 lines modifiedOffset 17, 15 lines modified
17 »       public·static·void·SetMainThread()17 »       public·static·void·SetMainThread()
18 »       {18 »       {
19 »       »       Constants._MainThread·=·Thread.CurrentThread;19 »       »       Constants._MainThread·=·Thread.CurrentThread;
20 »       }20 »       }
21 21
22 »       internal·static·int·GetBroadcastVersion()22 »       internal·static·int·GetBroadcastVersion()
23 »       {23 »       {
24 »       »       return·50603750;24 »       »       return·50607250;
25 »       }25 »       }
26 26
27 »       internal·static·bool·IsVersionModded()27 »       internal·static·bool·IsVersionModded()
28 »       {28 »       {
29 »       »       int·broadcastVersion·=·Constants.GetBroadcastVersion();29 »       »       int·broadcastVersion·=·Constants.GetBroadcastVersion();
30 »       »       return·broadcastVersion·==·Constants.MODDER_VERSION·||·Constants.GetVersionComponents(broadcastVersion).Item4·>=·25;30 »       »       return·broadcastVersion·==·Constants.MODDER_VERSION·||·Constants.GetVersionComponents(broadcastVersion).Item4·>=·25;
31 »       }31 »       }
Offset 180, 27 lines modifiedOffset 180, 27 lines modified
180 180
181 »       public·static·CultureInfo·CultureInfo·=·CultureInfo.CreateSpecificCulture("en-US");181 »       public·static·CultureInfo·CultureInfo·=·CultureInfo.CreateSpecificCulture("en-US");
182 182
183 »       public·static·readonly·int[]·CompatVersions·=·new·int[]·{·Constants.GetBroadcastVersion()·};183 »       public·static·readonly·int[]·CompatVersions·=·new·int[]·{·Constants.GetBroadcastVersion()·};
184 184
185 »       public·const·int·Year·=·2024;185 »       public·const·int·Year·=·2024;
186 186
187 »       public·const·int·Month·=·2;187 »       public·const·int·Month·=·4;
188 188
189 »       public·const·int·Day·=·3;189 »       public·const·int·Day·=·1;
190 190
191 »       public·const·int·Revision·=·0;191 »       public·const·int·Revision·=·0;
192 192
193 »       public·const·int·VisualRevision·=·0;193 »       public·const·int·VisualRevision·=·0;
194 194
195 »       public·const·string·AddressablesVersion·=·"2024_3_20_1015";195 »       public·const·string·AddressablesVersion·=·"2024_3_20_1015";
196 196
197 »       public·const·string·extraBuildVersionInfo·=·"(build·num:·4234)";197 »       public·const·string·extraBuildVersionInfo·=·"(build·num:·4431)";
198 198
199 »       public·const·int·pipelineBuildNumber·=·4234;199 »       public·const·int·pipelineBuildNumber·=·4431;
200 200
201 »       public·const·BuildEnvironment·environment·=·BuildEnvironment.Production;201 »       public·const·BuildEnvironment·environment·=·BuildEnvironment.Production;
202 202
203 »       public·const·byte·EmptyPlayerID·=·255;203 »       public·const·byte·EmptyPlayerID·=·255;
204 204
205 »       private·static·Thread·_MainThread;205 »       private·static·Thread·_MainThread;
206 206
977 B
Assembly-CSharp/ControllerButtonBehavior.cs
    
Offset 21, 14 lines modifiedOffset 21, 18 lines modified
21 »       {21 »       {
22 »       »       if·(this.player.GetButtonDown((int)this.Action))22 »       »       if·(this.player.GetButtonDown((int)this.Action))
23 »       »       {23 »       »       {
24 »       »       »       if·(this.requiredMenuNames.Count·>·0·&&·!this.requiredMenuNames.Contains(ControllerManager.Instance.CurrentUiState.MenuName))24 »       »       »       if·(this.requiredMenuNames.Count·>·0·&&·!this.requiredMenuNames.Contains(ControllerManager.Instance.CurrentUiState.MenuName))
25 »       »       »       {25 »       »       »       {
26 »       »       »       »       return;26 »       »       »       »       return;
27 »       »       »       }27 »       »       »       }
 28 »       »       »       if·(this.restrictedMenuNames.Count·>·0·&&·this.restrictedMenuNames.Contains(ControllerManager.Instance.CurrentUiState.MenuName))
 29 »       »       »       {
 30 »       »       »       »       return;
 31 »       »       »       }
28 »       »       »       Action·onPressedEvent·=·this.OnPressedEvent;32 »       »       »       Action·onPressedEvent·=·this.OnPressedEvent;
29 »       »       »       if·(onPressedEvent·!=·null)33 »       »       »       if·(onPressedEvent·!=·null)
30 »       »       »       {34 »       »       »       {
31 »       »       »       »       onPressedEvent();35 »       »       »       »       onPressedEvent();
32 »       »       »       }36 »       »       »       }
33 »       »       »       ButtonBehavior·component·=·base.GetComponent<ButtonBehavior>();37 »       »       »       ButtonBehavior·component·=·base.GetComponent<ButtonBehavior>();
34 »       »       »       if·(component)38 »       »       »       if·(component)
Offset 59, 9 lines modifiedOffset 63, 11 lines modified
59 63
60 »       public·RewiredConstsEnum.Action·Action;64 »       public·RewiredConstsEnum.Action·Action;
61 65
62 »       public·GameObject·requiredMenuObject;66 »       public·GameObject·requiredMenuObject;
63 67
64 »       public·List<string>·requiredMenuNames·=·new·List<string>();68 »       public·List<string>·requiredMenuNames·=·new·List<string>();
65 69
 70 »       public·List<string>·restrictedMenuNames·=·new·List<string>();
 71
66 »       private·Player·player;72 »       private·Player·player;
67 }73 }
2.78 KB
Assembly-CSharp/ControllerManager.cs
    
Offset 560, 14 lines modifiedOffset 560, 22 lines modified
560 »       »       »       »       ButtonBehavior·buttonBehavior2·=·this.CurrentUiState.CurrentSelection·as·ButtonBehavior;560 »       »       »       »       ButtonBehavior·buttonBehavior2·=·this.CurrentUiState.CurrentSelection·as·ButtonBehavior;
561 »       »       »       »       if·(buttonBehavior2·!=·null·&&·buttonBehavior2.isActiveAndEnabled)561 »       »       »       »       if·(buttonBehavior2·!=·null·&&·buttonBehavior2.isActiveAndEnabled)
562 »       »       »       »       {562 »       »       »       »       {
563 »       »       »       »       »       buttonBehavior2.ReceiveClick();563 »       »       »       »       »       buttonBehavior2.ReceiveClick();
564 »       »       »       »       }564 »       »       »       »       }
565 »       »       »       }565 »       »       »       }
566 »       »       }566 »       »       }
 567 »       »       else·if·(this.IsButtonHeld)
 568 »       »       {
 569 »       »       »       PassiveUiElement·passiveUiElement3·=·this.CurrentUiState.CurrentSelection·as·PassiveUiElement;
 570 »       »       »       if·(passiveUiElement3·!=·null·&&·passiveUiElement3.isActiveAndEnabled·&&·passiveUiElement3.HandleRepeat)
 571 »       »       »       {
 572 »       »       »       »       passiveUiElement3.ReceiveRepeatDown();
 573 »       »       »       }
 574 »       »       }
567 »       »       this.deltaSinceLastUiHighlight·+=·Time.deltaTime;575 »       »       this.deltaSinceLastUiHighlight·+=·Time.deltaTime;
568 »       »       bool·flag·=·false;576 »       »       bool·flag·=·false;
569 »       »       bool·buttonDown·=·this.player.GetButtonDown(25);577 »       »       bool·buttonDown·=·this.player.GetButtonDown(25);
570 »       »       bool·buttonDown2·=·this.player.GetButtonDown(26);578 »       »       bool·buttonDown2·=·this.player.GetButtonDown(26);
571 »       »       bool·buttonDown3·=·this.player.GetButtonDown(27);579 »       »       bool·buttonDown3·=·this.player.GetButtonDown(27);
572 »       »       bool·buttonDown4·=·this.player.GetButtonDown(28);580 »       »       bool·buttonDown4·=·this.player.GetButtonDown(28);
573 »       »       float·num·=·0f;581 »       »       float·num·=·0f;
Offset 603, 18 lines modifiedOffset 611, 18 lines modified
603 »       »       »       »       »       return;611 »       »       »       »       »       return;
604 »       »       »       »       }612 »       »       »       »       }
605 »       »       »       }613 »       »       »       }
606 »       »       »       if·(this.deltaSinceLastUiHighlight·>·0.25f·||·!this.inputDetectedLastFrame·||·flag)614 »       »       »       if·(this.deltaSinceLastUiHighlight·>·0.25f·||·!this.inputDetectedLastFrame·||·flag)
607 »       »       »       {615 »       »       »       {
608 »       »       »       »       UiElement·uiElement·=·null;616 »       »       »       »       UiElement·uiElement·=·null;
609 »       »       »       »       Vector2·vector·=·this.CurrentUiState.CurrentSelection.transform.position;617 »       »       »       »       Vector2·vector·=·this.CurrentUiState.CurrentSelection.transform.position;
610 »       »       »       »       PassiveUiElement·passiveUiElement3·=·this.CurrentUiState.CurrentSelection·as·PassiveUiElement;618 »       »       »       »       PassiveUiElement·passiveUiElement4·=·this.CurrentUiState.CurrentSelection·as·PassiveUiElement;
611 »       »       »       »       if·(passiveUiElement3·!=·null·&&·passiveUiElement3.Colliders.Length·!=·0)619 »       »       »       »       if·(passiveUiElement4·!=·null·&&·passiveUiElement4.Colliders.Length·!=·0)
612 »       »       »       »       {620 »       »       »       »       {
613 »       »       »       »       »       vector·=·passiveUiElement3.Colliders[0].bounds.center;621 »       »       »       »       »       vector·=·passiveUiElement4.Colliders[0].bounds.center;
614 »       »       »       »       }622 »       »       »       »       }
615 »       »       »       »       Vector2·vector2·=·new·Vector3(num,·num2);623 »       »       »       »       Vector2·vector2·=·new·Vector3(num,·num2);
616 »       »       »       »       if·(this.CurrentUiState.CurrentSelection.ControllerNav.mode·==·ControllerNavigation.Mode.Explicit)624 »       »       »       »       if·(this.CurrentUiState.CurrentSelection.ControllerNav.mode·==·ControllerNavigation.Mode.Explicit)
617 »       »       »       »       {625 »       »       »       »       {
618 »       »       »       »       »       AxisDirection·axisDirection·=·this.FindClosestDirection(vector2);626 »       »       »       »       »       AxisDirection·axisDirection·=·this.FindClosestDirection(vector2);
619 »       »       »       »       »       uiElement·=·this.FindUiElementByExplicitNavigation(this.CurrentUiState.CurrentSelection,·this.CurrentUiState.CurrentSelection,·axisDirection);627 »       »       »       »       »       uiElement·=·this.FindUiElementByExplicitNavigation(this.CurrentUiState.CurrentSelection,·this.CurrentUiState.CurrentSelection,·axisDirection);
620 »       »       »       »       }628 »       »       »       »       }
Offset 952, 15 lines modifiedOffset 960, 15 lines modified
952 »       »       »       if·(DestroyableSingleton<PassiveButtonManager>.InstanceExists)960 »       »       »       if·(DestroyableSingleton<PassiveButtonManager>.InstanceExists)
953 »       »       »       {961 »       »       »       {
954 »       »       »       »       DestroyableSingleton<PassiveButtonManager>.Instance.LoseFocusForAll();962 »       »       »       »       DestroyableSingleton<PassiveButtonManager>.Instance.LoseFocusForAll();
955 »       »       »       }963 »       »       »       }
956 »       »       »       if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick)964 »       »       »       if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick)
957 »       »       »       {965 »       »       »       {
958 »       »       »       »       selection.ReceiveMouseOver();966 »       »       »       »       selection.ReceiveMouseOver();
959 »       »       »       »       if·(selection.GetComponent<ColorChip>()·||·selection.GetComponent<AnnouncementPanel>())967 »       »       »       »       if·(selection.GetComponent<ColorChip>()·||·selection.GetComponent<AnnouncementPanel>()·||·selection.GetComponent<ViewSettingsTabButton>())
960 »       »       »       »       {968 »       »       »       »       {
961 »       »       »       »       »       (selection·as·PassiveButton).OnClick.Invoke();969 »       »       »       »       »       (selection·as·PassiveButton).OnClick.Invoke();
962 »       »       »       »       }970 »       »       »       »       }
963 »       »       »       }971 »       »       »       }
964 »       »       »       this.CurrentUiState.CurrentSelection·=·selection;972 »       »       »       this.CurrentUiState.CurrentSelection·=·selection;
965 »       »       »       this.deltaSinceLastUiHighlight·=·0f;973 »       »       »       this.deltaSinceLastUiHighlight·=·0f;
966 »       »       »       return;974 »       »       »       return;
439 B
Assembly-CSharp/CookableFish.cs
Ordering differences only
    
Offset 127, 16 lines modifiedOffset 127, 16 lines modified
127 127
128 »       [SerializeField]128 »       [SerializeField]
129 »       private·Sprite·cookedFish;129 »       private·Sprite·cookedFish;
130 130
131 »       [SerializeField]131 »       [SerializeField]
132 »       private·GameObject·glyphActionGO;132 »       private·GameObject·glyphActionGO;
133 133
134 »       [Header("Audio")] 
135 »       [SerializeField]134 »       [SerializeField]
 135 »       [Header("Audio")]
136 »       private·AudioClip·onGrillSfx;136 »       private·AudioClip·onGrillSfx;
137 137
138 »       [SerializeField]138 »       [SerializeField]
139 »       private·AudioClip·onFlipSfx;139 »       private·AudioClip·onFlipSfx;
140 140
141 »       [SerializeField]141 »       [SerializeField]
142 »       private·AudioClip·onFinishCookingSfx;142 »       private·AudioClip·onFinishCookingSfx;
2.03 KB
Assembly-CSharp/CosmeticData.cs
    
Offset 1, 12 lines modifiedOffset 1, 13 lines modified
1 using·System;1 using·System;
2 using·System.Collections;2 using·System.Collections;
3 using·System.Collections.Generic;3 using·System.Collections.Generic;
4 using·Innersloth.Assets;4 using·Innersloth.Assets;
5 using·UnityEngine;5 using·UnityEngine;
 6 using·UnityEngine.AddressableAssets;
6 7
7 public·class·CosmeticData·:·ScriptableObject,·IBuyable8 public·class·CosmeticData·:·ScriptableObject,·IBuyable
8 {9 {
9 »       public·string·ProdId10 »       public·string·ProdId
10 »       {11 »       {
11 »       »       get12 »       »       get
12 »       »       {13 »       »       {
Offset 76, 23 lines modifiedOffset 77, 50 lines modified
76 »       public·virtual·IEnumerator·CoLoadIcon(Action<Sprite,·AddressableAsset>·onLoaded)77 »       public·virtual·IEnumerator·CoLoadIcon(Action<Sprite,·AddressableAsset>·onLoaded)
77 »       {78 »       {
78 »       »       yield·return·null;79 »       »       yield·return·null;
79 »       »       onLoaded(null,·null);80 »       »       onLoaded(null,·null);
80 »       »       yield·break;81 »       »       yield·break;
81 »       }82 »       }
82 83
83 »       public·void·SetPreview(SpriteRenderer·renderer,·int·color)84 »       public·void·CoLoadPreview(Action<Sprite,·AddressableAsset>·onLoaded)
84 »       {85 »       {
85 »       »       renderer.sprite·=·this.SpritePreview; 
86 »       »       if·(Application.isPlaying)86 »       »       Sprite·sprite·=·null;
 87 »       »       if·(this.PreviewData.RuntimeKeyIsValid())
87 »       »       {88 »       »       {
88 »       »       »       PlayerMaterial.SetColors(color,·renderer);89 »       »       »       AddressableAsset<PreviewViewData>·asset·=·new·AddressableAsset<PreviewViewData>(this.PreviewData);
 90 »       »       »       asset.LoadAsync(delegate
 91 »       »       »       {
 92 »       »       »       »       PreviewViewData·asset2·=·asset.GetAsset();
 93 »       »       »       »       sprite·=·((asset2·!=·null)·?·asset2.PreviewSprite·:·null);
 94 »       »       »       »       onLoaded(sprite,·asset);
 95 »       »       »       },·null,·null);
89 »       »       }96 »       »       }
90 »       }97 »       }
91 98
 99 »       public·void·SetPreview(SpriteRenderer·renderer,·int·color)
 100 »       {
 101 »       »       this.CoLoadPreview(delegate(Sprite·sprite,·AddressableAsset·asset)
 102 »       »       {
 103 »       »       »       if·(renderer·!=·null)
 104 »       »       »       {
 105 »       »       »       »       renderer.sprite·=·sprite;
 106 »       »       »       »       AddressableAssetHandler.AddToGameObject(renderer.gameObject,·asset);
 107 »       »       »       »       if·(Application.isPlaying)
 108 »       »       »       »       {
 109 »       »       »       »       »       PlayerMaterial.SetColors(color,·renderer);
 110 »       »       »       »       »       return;
 111 »       »       »       »       }
 112 »       »       »       }
 113 »       »       »       else
 114 »       »       »       {
 115 »       »       »       »       asset.Unload();
 116 »       »       »       }
 117 »       »       });
 118 »       }
 119
92 »       public·const·string·TranslationPrefix·=·"Cosmetic.";120 »       public·const·string·TranslationPrefix·=·"Cosmetic.";
93 121
94 »       public·List<Platforms>·unlockOnSelectPlatforms;122 »       public·List<Platforms>·unlockOnSelectPlatforms;
95 123
96 »       public·bool·freeRedeemableCosmetic;124 »       public·bool·freeRedeemableCosmetic;
97 125
98 »       public·int·redeemPopUpColor·=·-1;126 »       public·int·redeemPopUpColor·=·-1;
Offset 115, 11 lines modifiedOffset 143, 11 lines modified
115 143
116 »       public·int·displayOrder;144 »       public·int·displayOrder;
117 145
118 »       public·bool·NotInStore;146 »       public·bool·NotInStore;
119 147
120 »       public·bool·Free;148 »       public·bool·Free;
121 149
122 »       public·Sprite·SpritePreview;150 »       public·AssetReference·PreviewData;
123 151
124 »       public·bool·PreviewCrewmateColor;152 »       public·bool·PreviewCrewmateColor;
125 }153 }
1.72 KB
Assembly-CSharp/CosmeticGroups.cs
    
Offset 25, 19 lines modifiedOffset 25, 29 lines modified
25 »       }25 »       }
26 26
27 »       public·bool·TryGetReleaseGroup(CosmeticData·cosmetic,·out·CosmeticReleaseGroup·output)27 »       public·bool·TryGetReleaseGroup(CosmeticData·cosmetic,·out·CosmeticReleaseGroup·output)
28 »       {28 »       {
29 »       »       return·this.TryGetGroup<CosmeticReleaseGroup>(this.releaseGroups,·cosmetic,·out·output);29 »       »       return·this.TryGetGroup<CosmeticReleaseGroup>(this.releaseGroups,·cosmetic,·out·output);
30 »       }30 »       }
31 31
 32 »       public·int·GetReleaseGroupIndex(CosmeticData·cosmetic)
 33 »       {
 34 »       »       return·this.GetGroupItemIndex<CosmeticReleaseGroup>(this.releaseGroups,·cosmetic);
 35 »       }
 36
 37 »       public·int·GetVariantGroupIndex(CosmeticData·cosmetic)
 38 »       {
 39 »       »       return·this.GetGroupItemIndex<CosmeticVariantGroup>(this.variantGroups,·cosmetic);
 40 »       }
 41
32 »       public·DateTime·GetReleaseGroupDate(CosmeticData·cosmetic)42 »       public·DateTime·GetReleaseGroupDate(CosmeticData·cosmetic)
33 »       {43 »       {
34 »       »       foreach·(CosmeticReleaseGroup·cosmeticReleaseGroup·in·this.releaseGroups)44 »       »       foreach·(CosmeticReleaseGroup·cosmeticReleaseGroup·in·this.releaseGroups)
35 »       »       {45 »       »       {
36 »       »       »       if·(!string.IsNullOrWhiteSpace(cosmeticReleaseGroup.DateString)·&&·cosmeticReleaseGroup.Contains(cosmetic.ProductId))46 »       »       »       if·(!string.IsNullOrWhiteSpace(cosmeticReleaseGroup.DateString)·&&·cosmeticReleaseGroup.Contains(cosmetic))
37 »       »       »       {47 »       »       »       {
38 »       »       »       »       return·Constants.ParseDate(cosmeticReleaseGroup.DateString);48 »       »       »       »       return·Constants.ParseDate(cosmeticReleaseGroup.DateString);
39 »       »       »       }49 »       »       »       }
40 »       »       }50 »       »       }
41 »       »       return·DateTime.MinValue;51 »       »       return·DateTime.MinValue;
42 »       }52 »       }
43 53
Offset 51, 14 lines modifiedOffset 61, 30 lines modified
51 »       »       »       »       return·true;61 »       »       »       »       return·true;
52 »       »       »       }62 »       »       »       }
53 »       »       }63 »       »       }
54 »       »       output·=·default(T);64 »       »       output·=·default(T);
55 »       »       return·false;65 »       »       return·false;
56 »       }66 »       }
57 67
 68 »       private·int·GetGroupItemIndex<T>(T[]·groups,·CosmeticData·cosmetic)·where·T·:·AbstractCosmeticGroup
 69 »       {
 70 »       »       foreach·(T·t·in·groups)
 71 »       »       {
 72 »       »       »       if·(t.Contains(cosmetic))
 73 »       »       »       {
 74 »       »       »       »       int·num·=·t.IndexOf(cosmetic);
 75 »       »       »       »       if·(num·>=·0)
 76 »       »       »       »       {
 77 »       »       »       »       »       return·num;
 78 »       »       »       »       }
 79 »       »       »       }
 80 »       »       }
 81 »       »       return·int.MaxValue;
 82 »       }
 83
58 »       public·void·RebuildGroups(CosmeticVariantGroup[]·variantGroups,·CosmeticReleaseGroup[]·releaseGroups)84 »       public·void·RebuildGroups(CosmeticVariantGroup[]·variantGroups,·CosmeticReleaseGroup[]·releaseGroups)
59 »       {85 »       {
60 »       »       this.variantGroups·=·variantGroups;86 »       »       this.variantGroups·=·variantGroups;
61 »       »       this.releaseGroups·=·releaseGroups;87 »       »       this.releaseGroups·=·releaseGroups;
62 »       }88 »       }
63 89
64 »       [SerializeField]90 »       [SerializeField]
1.33 KB
Assembly-CSharp/CosmeticsCache.cs
    
Offset 24, 15 lines modifiedOffset 24, 15 lines modified
24 »       »       HashSet<string>·hashSet6·=·new·HashSet<string>();24 »       »       HashSet<string>·hashSet6·=·new·HashSet<string>();
25 »       »       hashSet6.Add("pet_EmptyPet");25 »       »       hashSet6.Add("pet_EmptyPet");
26 »       »       HashSet<string>·petIds·=·hashSet6;26 »       »       HashSet<string>·petIds·=·hashSet6;
27 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)27 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
28 »       »       {28 »       »       {
29 »       »       »       if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null))29 »       »       »       if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null))
30 »       »       »       {30 »       »       »       {
31 »       »       »       »       GameData.PlayerOutfit·currentOutfit·=·playerControl.CurrentOutfit;31 »       »       »       »       NetworkedPlayerInfo.PlayerOutfit·currentOutfit·=·playerControl.CurrentOutfit;
32 »       »       »       »       hashSet2.Add(currentOutfit.HatId);32 »       »       »       »       hashSet2.Add(currentOutfit.HatId);
33 »       »       »       »       skinIds.Add(currentOutfit.SkinId);33 »       »       »       »       skinIds.Add(currentOutfit.SkinId);
34 »       »       »       »       visorIds.Add(currentOutfit.VisorId);34 »       »       »       »       visorIds.Add(currentOutfit.VisorId);
35 »       »       »       »       namePlateIds.Add(currentOutfit.NamePlateId);35 »       »       »       »       namePlateIds.Add(currentOutfit.NamePlateId);
36 »       »       »       »       petIds.Add(currentOutfit.PetId);36 »       »       »       »       petIds.Add(currentOutfit.PetId);
37 »       »       »       }37 »       »       »       }
38 »       »       }38 »       »       }
Offset 253, 15 lines modifiedOffset 253, 15 lines modified
253 »       »       if·(addressableAssetGroup·==·null)253 »       »       if·(addressableAssetGroup·==·null)
254 »       »       {254 »       »       {
255 »       »       »       return;255 »       »       »       return;
256 »       »       }256 »       »       }
257 »       »       addressableAssetGroup.Destroy();257 »       »       addressableAssetGroup.Destroy();
258 »       }258 »       }
259 259
260 »       public·IEnumerator·CoPopulateFromOutfit(GameData.PlayerOutfit·outfit)260 »       public·IEnumerator·CoPopulateFromOutfit(NetworkedPlayerInfo.PlayerOutfit·outfit)
261 »       {261 »       {
262 »       »       yield·return·this.CoAddHat(outfit.HatId);262 »       »       yield·return·this.CoAddHat(outfit.HatId);
263 »       »       yield·return·this.CoAddVisor(outfit.VisorId);263 »       »       yield·return·this.CoAddVisor(outfit.VisorId);
264 »       »       yield·return·this.CoAddSkin(outfit.SkinId);264 »       »       yield·return·this.CoAddSkin(outfit.SkinId);
265 »       »       yield·return·this.CoAddPet(outfit.PetId);265 »       »       yield·return·this.CoAddPet(outfit.PetId);
266 »       »       yield·return·this.CoAddNameplate(outfit.NamePlateId);266 »       »       yield·return·this.CoAddNameplate(outfit.NamePlateId);
267 »       »       yield·break;267 »       »       yield·break;
2.43 KB
Assembly-CSharp/CosmeticsLayer.cs
    
Offset 145, 14 lines modifiedOffset 145, 33 lines modified
145 »       »       if·(this.currentPet)145 »       »       if·(this.currentPet)
146 »       »       {146 »       »       {
147 »       »       »       this.currentPet.Visible·=·this.visible;147 »       »       »       this.currentPet.Visible·=·this.visible;
148 »       »       }148 »       »       }
149 »       »       this.UpdateNameVisibility();149 »       »       this.UpdateNameVisibility();
150 »       }150 »       }
151 151
 152 »       public·void·SetPhantomRoleAlpha(float·alphaValue)
 153 »       {
 154 »       »       this.currentBodySprite.BodySprite.color·=·this.currentBodySprite.BodySprite.color.SetAlpha(alphaValue);
 155 »       »       this.skin.layer.color·=·this.skin.layer.color.SetAlpha(alphaValue);
 156 »       »       this.hat.FrontLayer.color·=·this.hat.FrontLayer.color.SetAlpha(alphaValue);
 157 »       »       this.hat.BackLayer.color·=·this.hat.BackLayer.color.SetAlpha(alphaValue);
 158 »       »       this.visor.Alpha·=·alphaValue;
 159 »       »       if·(this.currentPet·!=·null)
 160 »       »       {
 161 »       »       »       this.currentPet.SetAlpha(alphaValue);
 162 »       »       »       this.PettingHand.SetAlpha(alphaValue);
 163 »       »       }
 164 »       }
 165
 166 »       public·float·GetPhantomRoleAlpha()
 167 »       {
 168 »       »       return·this.currentBodySprite.BodySprite.color.a;
 169 »       }
 170
152 »       public·void·SetPetVisible(bool·v)171 »       public·void·SetPetVisible(bool·v)
153 »       {172 »       {
154 »       »       if·(this.currentPet)173 »       »       if·(this.currentPet)
155 »       »       {174 »       »       {
156 »       »       »       this.currentPet.Visible·=·v;175 »       »       »       this.currentPet.Visible·=·v;
157 »       »       }176 »       »       }
158 »       }177 »       }
Offset 251, 14 lines modifiedOffset 270, 19 lines modified
251 »       {270 »       {
252 »       »       if·(this.visor)271 »       »       if·(this.visor)
253 »       »       {272 »       »       {
254 »       »       »       this.visor.transform.localPosition·=·pos;273 »       »       »       this.visor.transform.localPosition·=·pos;
255 »       »       }274 »       »       }
256 »       }275 »       }
257 276
 277 »       public·SkinViewData·GetSkinView()
 278 »       {
 279 »       »       return·this.skin.skin;
 280 »       }
 281
258 »       public·void·FixSkinSprite(Sprite·skinSprite)282 »       public·void·FixSkinSprite(Sprite·skinSprite)
259 »       {283 »       {
260 »       »       this.skin.animator.Stop();284 »       »       this.skin.animator.Stop();
261 »       »       this.skin.layer.sprite·=·skinSprite;285 »       »       this.skin.layer.sprite·=·skinSprite;
262 »       }286 »       }
263 287
264 »       public·PetBehaviour·GetPet()288 »       public·PetBehaviour·GetPet()
Offset 567, 21 lines modifiedOffset 591, 35 lines modified
567 »       {591 »       {
568 »       »       this.visor.gameObject.SetActive(active);592 »       »       this.visor.gameObject.SetActive(active);
569 »       }593 »       }
570 594
571 »       public·void·SetHatAndVisorIdle(int·colorId)595 »       public·void·SetHatAndVisorIdle(int·colorId)
572 »       {596 »       {
573 »       »       this.hat.SetIdleAnim(colorId);597 »       »       this.hat.SetIdleAnim(colorId);
 598 »       »       if·(this.visor.isActiveAndEnabled)
 599 »       »       {
 600 »       »       »       this.visor.SetIdleAnim(colorId);
 601 »       »       »       return;
 602 »       »       }
574 »       »       this.ToggleVisor(true);603 »       »       this.ToggleVisor(true);
575 »       }604 »       }
576 605
 606 »       public·void·SetHatLeftFacingVictim(bool·leftFacingVictim)
 607 »       {
 608 »       »       this.hat.SetShouldFaceLeft(leftFacingVictim);
 609 »       }
 610
577 »       public·void·SetHatAndVisorOnFloor()611 »       public·void·SetHatOnFloor()
578 »       {612 »       {
579 »       »       this.hat.SetFloorAnim();613 »       »       this.hat.SetFloorAnim();
 614 »       }
 615
 616 »       public·void·SetVisorOnFloor()
 617 »       {
580 »       »       this.hat.SetFloorAnim();618 »       »       this.visor.SetFloorAnim();
581 »       }619 »       }
582 620
583 »       public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type)621 »       public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type)
584 »       {622 »       {
585 »       »       this.hat.SetMaskType(type);623 »       »       this.hat.SetMaskType(type);
586 »       »       this.visor.SetMaskType(type);624 »       »       this.visor.SetMaskType(type);
587 »       }625 »       }
Offset 1128, 14 lines modifiedOffset 1166, 15 lines modified
1128 »       »       this.skin.UnloadAddressableAsset(asset);1166 »       »       this.skin.UnloadAddressableAsset(asset);
1129 »       }1167 »       }
1130 1168
1131 »       public·void·AnimateClimb(bool·down)1169 »       public·void·AnimateClimb(bool·down)
1132 »       {1170 »       {
1133 »       »       this.skin.SetClimb(down);1171 »       »       this.skin.SetClimb(down);
1134 »       »       this.hat.SetClimbAnim();1172 »       »       this.hat.SetClimbAnim();
 1173 »       »       this.visor.SetClimbAnim(this.bodyType);
1135 »       }1174 »       }
1136 1175
1137 »       public·void·AnimatePetMourning()1176 »       public·void·AnimatePetMourning()
1138 »       {1177 »       {
1139 »       »       if·(this.currentPet)1178 »       »       if·(this.currentPet)
1140 »       »       {1179 »       »       {
1141 »       »       »       this.currentPet.SetMourning();1180 »       »       »       this.currentPet.SetMourning();
710 B
Assembly-CSharp/CosmicubeCell.cs
    
Offset 137, 15 lines modifiedOffset 137, 15 lines modified
137 »       public·void·SetPositionAndScale(UnlockableCosmetic·cosmetic)137 »       public·void·SetPositionAndScale(UnlockableCosmetic·cosmetic)
138 »       {138 »       {
139 »       »       if·(cosmetic.unlockableCosmetic)139 »       »       if·(cosmetic.unlockableCosmetic)
140 »       »       {140 »       »       {
141 »       »       »       if·(!(cosmetic.unlockableCosmetic·is·NamePlateData))141 »       »       »       if·(!(cosmetic.unlockableCosmetic·is·NamePlateData))
142 »       »       »       {142 »       »       »       {
143 »       »       »       »       this.icon.transform.localScale·=·new·Vector3(0.6f,·0.6f,·1f);143 »       »       »       »       this.icon.transform.localScale·=·new·Vector3(0.6f,·0.6f,·1f);
144 »       »       »       »       this.icon.transform.localPosition·=·new·Vector3(0f,·0f,·-3f);144 »       »       »       »       this.icon.transform.localPosition·=·new·Vector3(this.icon.transform.localPosition.x,·this.icon.transform.localPosition.y,·-3f);
145 »       »       »       »       return;145 »       »       »       »       return;
146 »       »       »       }146 »       »       »       }
147 »       »       »       this.icon.transform.localScale·=·new·Vector3(0.7f,·0.7f,·1f);147 »       »       »       this.icon.transform.localScale·=·new·Vector3(0.7f,·0.7f,·1f);
148 »       »       »       this.icon.transform.localPosition·=·new·Vector3(-0.65f,·-0.14f,·-3f);148 »       »       »       this.icon.transform.localPosition·=·new·Vector3(-0.65f,·-0.14f,·-3f);
149 »       »       }149 »       »       }
150 »       }150 »       }
151 151
844 B
Assembly-CSharp/CrankGeneratorMinigame.cs
Ordering differences only
    
Offset 139, 24 lines modifiedOffset 139, 24 lines modified
139 »       »       return·audioClip;139 »       »       return·audioClip;
140 »       }140 »       }
141 141
142 »       private·static·readonly·string·SHADER_Y_PERCENT·=·"_PercentY";142 »       private·static·readonly·string·SHADER_Y_PERCENT·=·"_PercentY";
143 143
144 »       private·static·readonly·string·CRANK_MOTOR_SFX·=·"crankMotorLoop";144 »       private·static·readonly·string·CRANK_MOTOR_SFX·=·"crankMotorLoop";
145 145
146 »       [SerializeField] 
147 »       [Tooltip("Indicates·how·much·spinning·its·needed·to·complete·task")]146 »       [Tooltip("Indicates·how·much·spinning·its·needed·to·complete·task")]
 147 »       [SerializeField]
148 »       private·float·targetProgress·=·2000f;148 »       private·float·targetProgress·=·2000f;
149 149
150 »       [SerializeField]150 »       [SerializeField]
151 »       [Tooltip("How·fast·does·machine·loses·power·when·not·spinning")]151 »       [Tooltip("How·fast·does·machine·loses·power·when·not·spinning")]
152 »       private·float·progressDecay·=·250f;152 »       private·float·progressDecay·=·250f;
153 153
154 »       [SerializeField] 
155 »       [Tooltip("CrankAudioPlays·targetprogress/lightbulbRate")]154 »       [Tooltip("CrankAudioPlays·targetprogress/lightbulbRate")]
 155 »       [SerializeField]
156 »       private·int·crankAudioRate;156 »       private·int·crankAudioRate;
157 157
158 »       [SerializeField]158 »       [SerializeField]
159 »       private·SpriteRenderer·powerBarSpriteRenderer;159 »       private·SpriteRenderer·powerBarSpriteRenderer;
160 160
161 »       [SerializeField]161 »       [SerializeField]
162 »       private·Collider2D·crank;162 »       private·Collider2D·crank;
2.81 KB
Assembly-CSharp/CreditsController.cs
    
Offset 1, 23 lines modifiedOffset 1, 26 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·System.IO;3 using·System.IO;
4 using·CsvHelper;4 using·CsvHelper;
 5 using·Rewired;
5 using·TMPro;6 using·TMPro;
6 using·UnityEngine;7 using·UnityEngine;
7 using·UnityEngine.UI;8 using·UnityEngine.UI;
8 9
9 public·class·CreditsController·:·MonoBehaviour10 public·class·CreditsController·:·MonoBehaviour
10 {11 {
11 »       public·event·Action·OnFinish;12 »       public·event·Action·OnFinish;
12 13
13 »       private·void·Awake()14 »       private·void·Awake()
14 »       {15 »       {
15 »       »       this.creditsRect·=·this.creditMainPanel.GetComponent<RectTransform>();16 »       »       this.creditsRect·=·this.creditMainPanel.GetComponent<RectTransform>();
16 »       »       this.LoadCredits();17 »       »       this.LoadCredits();
 18 »       »       this.defaultCreditsScrollSpeed·=·this.creditScrollSpeed;
 19 »       »       this.player·=·ReInput.players.GetPlayer(0);
17 »       }20 »       }
18 21
19 »       private·void·Start()22 »       private·void·Start()
20 »       {23 »       {
21 »       »       this.remainingDelay·=·this.initialDelay;24 »       »       this.remainingDelay·=·this.initialDelay;
22 »       »       Debug.Log("First·Credit:·"·+·this.credits[0].columns[0]);25 »       »       Debug.Log("First·Credit:·"·+·this.credits[0].columns[0]);
23 »       »       GameObject·gameObject·=·base.gameObject;26 »       »       GameObject·gameObject·=·base.gameObject;
Offset 61, 25 lines modifiedOffset 64, 46 lines modified
61 »       }64 »       }
62 65
63 »       private·void·PauseUnpauseCreditsScroll()66 »       private·void·PauseUnpauseCreditsScroll()
64 »       {67 »       {
65 »       »       this.paused·=·!this.paused;68 »       »       this.paused·=·!this.paused;
66 »       }69 »       }
67 70
 71 »       private·void·Update()
 72 »       {
 73 »       »       if·(this.player.GetAxis(10)·!=·0f)
 74 »       »       {
 75 »       »       »       this.creditScrollSpeed·=·-this.player.GetAxis(10)·*·this.navCreditsScrollSpeed;
 76 »       »       »       return;
 77 »       »       }
 78 »       »       if·(this.player.GetButton(44)·||·this.player.GetButton(42))
 79 »       »       {
 80 »       »       »       this.creditScrollSpeed·=·(this.player.GetButton(44)·?·(-this.navCreditsScrollSpeed)·:·this.navCreditsScrollSpeed);
 81 »       »       »       return;
 82 »       »       }
 83 »       »       if·(Input.touchCount·>·0·||·Input.GetMouseButton(0))
 84 »       »       {
 85 »       »       »       this.creditScrollSpeed·=·this.navCreditsScrollSpeed;
 86 »       »       »       return;
 87 »       »       }
 88 »       »       this.creditScrollSpeed·=·this.defaultCreditsScrollSpeed;
 89 »       }
 90
68 »       private·void·FixedUpdate()91 »       private·void·FixedUpdate()
69 »       {92 »       {
70 »       »       if·(!this.paused)93 »       »       if·(!this.paused)
71 »       »       {94 »       »       {
72 »       »       »       if·(this.remainingDelay·>·0f)95 »       »       »       if·(this.remainingDelay·>·0f)
73 »       »       »       {96 »       »       »       {
74 »       »       »       »       this.remainingDelay·-=·Time.unscaledDeltaTime;97 »       »       »       »       this.remainingDelay·-=·Time.unscaledDeltaTime;
75 »       »       »       »       return;98 »       »       »       »       return;
76 »       »       »       }99 »       »       »       }
 100 »       »       »       float·num·=·Mathf.Clamp(this.creditMainPanel.transform.localPosition.y·+·this.creditScrollSpeed,·0f,·this.creditsRect.rect.height);
77 »       »       »       this.creditMainPanel.transform.localPosition·=·new·Vector2(this.creditMainPanel.transform.localPosition.x,·this.creditMainPanel.transform.localPosition.y·+·this.creditScrollSpeed);101 »       »       »       this.creditMainPanel.transform.localPosition·=·new·Vector2(this.creditMainPanel.transform.localPosition.x,·num);
78 »       »       »       if·(this.creditsRect.anchoredPosition.y·>=·this.creditsRect.rect.height·&&·this.OnFinish·!=·null)102 »       »       »       if·(this.creditsRect.localPosition.y·>=·this.creditsRect.rect.height·&&·this.OnFinish·!=·null)
79 »       »       »       {103 »       »       »       {
80 »       »       »       »       this.OnFinish();104 »       »       »       »       this.OnFinish();
81 »       »       »       }105 »       »       »       }
82 »       »       }106 »       »       }
83 »       }107 »       }
84 108
85 »       private·void·GenerateCreditEntry(CreditsController.CreditStruct·credit)109 »       private·void·GenerateCreditEntry(CreditsController.CreditStruct·credit)
Offset 169, 14 lines modifiedOffset 193, 20 lines modified
169 193
170 »       public·float·startPos·=·230f;194 »       public·float·startPos·=·230f;
171 195
172 »       private·float·remainingDelay;196 »       private·float·remainingDelay;
173 197
174 »       private·RectTransform·creditsRect;198 »       private·RectTransform·creditsRect;
175 199
 200 »       private·float·defaultCreditsScrollSpeed;
 201
 202 »       private·float·navCreditsScrollSpeed·=·100f;
 203
 204 »       private·Player·player;
 205
176 »       private·bool·paused;206 »       private·bool·paused;
177 207
178 »       public·List<CreditsController.FormatStruct>·formats;208 »       public·List<CreditsController.FormatStruct>·formats;
179 209
180 »       public·List<CreditsController.CreditStruct>·credits;210 »       public·List<CreditsController.CreditStruct>·credits;
181 211
182 »       public·enum·CreditType212 »       public·enum·CreditType
485 B
Assembly-CSharp/CrewmateRole.cs
    
Offset 9, 15 lines modifiedOffset 9, 15 lines modified
9 »       »       {9 »       »       {
10 »       »       »       return·false;10 »       »       »       return·false;
11 »       »       }11 »       »       }
12 »       }12 »       }
13 13
14 »       public·override·bool·CanUse(IUsable·console)14 »       public·override·bool·CanUse(IUsable·console)
15 »       {15 »       {
16 »       »       return·console·is·Console;16 »       »       return·console·is·ZiplineConsole·||·console·is·Ladder·||·console·is·PlatformConsole·||·console·is·Console·||·console·is·DoorConsole;
17 »       }17 »       }
18 18
19 »       public·override·bool·DidWin(GameOverReason·gameOverReason)19 »       public·override·bool·DidWin(GameOverReason·gameOverReason)
20 »       {20 »       {
21 »       »       return·GameManager.Instance.DidHumansWin(gameOverReason);21 »       »       return·GameManager.Instance.DidHumansWin(gameOverReason);
22 »       }22 »       }
23 23
1.92 KB
Assembly-CSharp/CrewmatesKilledTracker.cs
    
Offset 15, 15 lines modifiedOffset 15, 15 lines modified
15 »       {15 »       {
16 »       »       if·(this.crewmateSprites·==·null)16 »       »       if·(this.crewmateSprites·==·null)
17 »       »       {17 »       »       {
18 »       »       »       return;18 »       »       »       return;
19 »       »       }19 »       »       }
20 »       »       int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc)20 »       »       int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc)
21 »       »       {21 »       »       {
22 »       »       »       GameData.PlayerInfo·data·=·pc.Data;22 »       »       »       NetworkedPlayerInfo·data·=·pc.Data;
23 »       »       »       return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor·&&·pc.Data.IsDead;23 »       »       »       return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor·&&·pc.Data.IsDead;
24 »       »       });24 »       »       });
25 »       »       for·(int·i·=·0;·i·<·this.crewmateSprites.Count;·i++)25 »       »       for·(int·i·=·0;·i·<·this.crewmateSprites.Count;·i++)
26 »       »       {26 »       »       {
27 »       »       »       if·(i·<·num)27 »       »       »       if·(i·<·num)
28 »       »       »       {28 »       »       »       {
29 »       »       »       »       if·(!this.crewmateSprites[i].IsKilled)29 »       »       »       »       if·(!this.crewmateSprites[i].IsKilled)
Offset 38, 15 lines modifiedOffset 38, 15 lines modified
38 »       »       }38 »       »       }
39 »       }39 »       }
40 40
41 »       public·void·OnCrewmateDisconnect()41 »       public·void·OnCrewmateDisconnect()
42 »       {42 »       {
43 »       »       int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc)43 »       »       int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·delegate(PlayerControl·pc)
44 »       »       {44 »       »       {
45 »       »       »       GameData.PlayerInfo·data·=·pc.Data;45 »       »       »       NetworkedPlayerInfo·data·=·pc.Data;
46 »       »       »       return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor;46 »       »       »       return·((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!pc.Data.Role.IsImpostor;
47 »       »       });47 »       »       });
48 »       »       for·(int·i·=·this.crewmates.Count·-·1;·i·>=·0;·i--)48 »       »       for·(int·i·=·this.crewmates.Count·-·1;·i·>=·0;·i--)
49 »       »       {49 »       »       {
50 »       »       »       if·(i·>=·num·-·1)50 »       »       »       if·(i·>=·num·-·1)
51 »       »       »       {51 »       »       »       {
52 »       »       »       »       this.crewmates.DestroyInstance(this.crewmates.GetInstance(i));52 »       »       »       »       this.crewmates.DestroyInstance(this.crewmates.GetInstance(i));
Offset 70, 15 lines modifiedOffset 70, 15 lines modified
70 »       private·void·Start()70 »       private·void·Start()
71 »       {71 »       {
72 »       »       this.crewmates.DestroyAll();72 »       »       this.crewmates.DestroyAll();
73 »       »       this.crewmateSprites·=·new·List<CrewmateTrackerEntry>(PlayerControl.AllPlayerControls.Count);73 »       »       this.crewmateSprites·=·new·List<CrewmateTrackerEntry>(PlayerControl.AllPlayerControls.Count);
74 »       »       int·num·=·0;74 »       »       int·num·=·0;
75 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)75 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
76 »       »       {76 »       »       {
77 »       »       »       GameData.PlayerInfo·data·=·playerControl.Data;77 »       »       »       NetworkedPlayerInfo·data·=·playerControl.Data;
78 »       »       »       if·(!(((data·!=·null)·?·data.Role·:·null)·==·null)·&&·!playerControl.Data.Role.IsImpostor)78 »       »       »       if·(!(((data·!=·null)·?·data.Role·:·null)·==·null)·&&·!playerControl.Data.Role.IsImpostor)
79 »       »       »       {79 »       »       »       {
80 »       »       »       »       CrewmateTrackerEntry·crewmateTrackerEntry·=·this.crewmates.Create<CrewmateTrackerEntry>();80 »       »       »       »       CrewmateTrackerEntry·crewmateTrackerEntry·=·this.crewmates.Create<CrewmateTrackerEntry>();
81 »       »       »       »       crewmateTrackerEntry.transform.localPosition·=·new·Vector3((float)num·*·this.crewmateSpacing,·0f,·0f);81 »       »       »       »       crewmateTrackerEntry.transform.localPosition·=·new·Vector3((float)num·*·this.crewmateSpacing,·0f,·0f);
82 »       »       »       »       crewmateTrackerEntry.transform.localScale·=·this.crewmateScale;82 »       »       »       »       crewmateTrackerEntry.transform.localScale·=·this.crewmateScale;
83 »       »       »       »       this.crewmateSprites.Add(crewmateTrackerEntry);83 »       »       »       »       this.crewmateSprites.Add(crewmateTrackerEntry);
84 »       »       »       »       num++;84 »       »       »       »       num++;
611 B
Assembly-CSharp/CubesTab.cs
    
Offset 63, 15 lines modifiedOffset 63, 15 lines modified
63 »       »       {63 »       »       {
64 »       »       »       this.podIcon.sprite·=·sprite;64 »       »       »       this.podIcon.sprite·=·sprite;
65 »       »       }));65 »       »       }));
66 »       »       this.activateButton.SetButtonEnableState(!DestroyableSingleton<CosmicubeManager>.Instance.IsCompleted(cube)·||·flag);66 »       »       this.activateButton.SetButtonEnableState(!DestroyableSingleton<CosmicubeManager>.Instance.IsCompleted(cube)·||·flag);
67 »       »       for·(int·i·=·0;·i·<·this.ColorChips.Count;·i++)67 »       »       for·(int·i·=·0;·i·<·this.ColorChips.Count;·i++)
68 »       »       {68 »       »       {
69 »       »       »       ColorChip·colorChip·=·this.ColorChips[i];69 »       »       »       ColorChip·colorChip·=·this.ColorChips[i];
70 »       »       »       colorChip.PlayerEquippedForeground.SetActive(chip·==·colorChip);70 »       »       »       colorChip.PlayerEquippedForeground.SetActive(chip·==·colorChip·&&·flag);
71 »       »       }71 »       »       }
72 »       }72 »       }
73 73
74 »       public·override·ColorChip·GetDefaultSelectable()74 »       public·override·ColorChip·GetDefaultSelectable()
75 »       {75 »       {
76 »       »       if·(this.ColorChips.Count·>·0)76 »       »       if·(this.ColorChips.Count·>·0)
77 »       »       {77 »       »       {
655 B
Assembly-CSharp/CutVegetablesMinigame.cs
Ordering differences only
    
Offset 177, 26 lines modifiedOffset 177, 26 lines modified
177 177
178 »       [SerializeField]178 »       [SerializeField]
179 »       private·Transform·endArea;179 »       private·Transform·endArea;
180 180
181 »       [SerializeField]181 »       [SerializeField]
182 »       private·GameObject·arrow;182 »       private·GameObject·arrow;
183 183
184 »       [SerializeField] 
185 »       [Header("Knife")]184 »       [Header("Knife")]
 185 »       [SerializeField]
186 »       private·SpriteRenderer·knife;186 »       private·SpriteRenderer·knife;
187 187
188 »       [SerializeField]188 »       [SerializeField]
189 »       private·Sprite·cuttingKnifeSprite;189 »       private·Sprite·cuttingKnifeSprite;
190 190
191 »       [SerializeField]191 »       [SerializeField]
192 »       private·float·knifeCutYOffset·=·1f;192 »       private·float·knifeCutYOffset·=·1f;
193 193
194 »       [Header("Audio")] 
195 »       [SerializeField]194 »       [SerializeField]
 195 »       [Header("Audio")]
196 »       private·AudioClip·getSfx;196 »       private·AudioClip·getSfx;
197 197
198 »       [SerializeField]198 »       [SerializeField]
199 »       private·AudioClip·finishSfx;199 »       private·AudioClip·finishSfx;
200 200
201 »       [SerializeField]201 »       [SerializeField]
202 »       private·AudioClip[]·cutSfx;202 »       private·AudioClip[]·cutSfx;
786 B
Assembly-CSharp/DeadBody.cs
    
Offset 18, 15 lines modifiedOffset 18, 15 lines modified
18 »       »       »       return;18 »       »       »       return;
19 »       »       }19 »       »       }
20 »       »       Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition();20 »       »       Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition();
21 »       »       Vector2·truePosition2·=·this.TruePosition;21 »       »       Vector2·truePosition2·=·this.TruePosition;
22 »       »       if·(Vector2.Distance(truePosition2,·truePosition)·<=·PlayerControl.LocalPlayer.MaxReportDistance·&&·PlayerControl.LocalPlayer.CanMove·&&·!PhysicsHelpers.AnythingBetween(truePosition,·truePosition2,·Constants.ShipAndObjectsMask,·false))22 »       »       if·(Vector2.Distance(truePosition2,·truePosition)·<=·PlayerControl.LocalPlayer.MaxReportDistance·&&·PlayerControl.LocalPlayer.CanMove·&&·!PhysicsHelpers.AnythingBetween(truePosition,·truePosition2,·Constants.ShipAndObjectsMask,·false))
23 »       »       {23 »       »       {
24 »       »       »       this.Reported·=·true;24 »       »       »       this.Reported·=·true;
25 »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.ParentId);25 »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.ParentId);
26 »       »       »       PlayerControl.LocalPlayer.CmdReportDeadBody(playerById);26 »       »       »       PlayerControl.LocalPlayer.CmdReportDeadBody(playerById);
27 »       »       }27 »       »       }
28 »       }28 »       }
29 29
30 »       public·bool·Reported;30 »       public·bool·Reported;
31 31
32 »       public·byte·ParentId;32 »       public·byte·ParentId;
494 B
Assembly-CSharp/DeconControl.cs
    
Offset 39, 15 lines modifiedOffset 39, 15 lines modified
39 »       }39 »       }
40 40
41 »       public·void·Update()41 »       public·void·Update()
42 »       {42 »       {
43 »       »       this.cooldown·=·Mathf.Max(this.cooldown·-·Time.deltaTime,·0f);43 »       »       this.cooldown·=·Mathf.Max(this.cooldown·-·Time.deltaTime,·0f);
44 »       }44 »       }
45 45
46 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)46 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
47 »       {47 »       {
48 »       »       if·(this.System.CurState·!=·DeconSystem.States.Idle)48 »       »       if·(this.System.CurState·!=·DeconSystem.States.Idle)
49 »       »       {49 »       »       {
50 »       »       »       canUse·=·false;50 »       »       »       canUse·=·false;
51 »       »       »       couldUse·=·false;51 »       »       »       couldUse·=·false;
52 »       »       »       return·0f;52 »       »       »       return·0f;
53 »       »       }53 »       »       }
763 B
Assembly-CSharp/DoorConsole.cs
    
Offset 29, 18 lines modifiedOffset 29, 18 lines modified
29 29
30 »       public·void·Awake()30 »       public·void·Awake()
31 »       {31 »       {
32 »       »       this.MyDoor·=·base.GetComponent<OpenableDoor>();32 »       »       this.MyDoor·=·base.GetComponent<OpenableDoor>();
33 »       »       this.Image·=·base.GetComponent<SpriteRenderer>();33 »       »       this.Image·=·base.GetComponent<SpriteRenderer>();
34 »       }34 »       }
35 35
36 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)36 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
37 »       {37 »       {
38 »       »       float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position);38 »       »       float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position);
39 »       »       couldUse·=·!pc.IsDead·&&·!this.MyDoor.IsOpen;39 »       »       couldUse·=·!pc.IsDead·&&·!this.MyDoor.IsOpen·&&·pc.Role.CanUse(this);
40 »       »       canUse·=·couldUse·&&·num·<=·this.UsableDistance;40 »       »       canUse·=·couldUse·&&·num·<=·this.UsableDistance;
41 »       »       return·num;41 »       »       return·num;
42 »       }42 »       }
43 43
44 »       public·void·SetOutline(bool·on,·bool·mainTarget)44 »       public·void·SetOutline(bool·on,·bool·mainTarget)
45 »       {45 »       {
46 »       »       if·(this.Image)46 »       »       if·(this.Image)
2.28 KB
Assembly-CSharp/DummyAnalytics.cs
    
Offset 1, 50 lines modifiedOffset 1, 50 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·AmongUs.GameOptions;3 using·AmongUs.GameOptions;
4 4
5 public·class·DummyAnalytics·:·IAnalyticsReporter5 public·class·DummyAnalytics·:·IAnalyticsReporter
6 {6 {
7 »       public·void·StartGame(GameData.PlayerInfo·localPlayer,·int·playerCount,·int·impostorCount,·NetworkModes·networkMode,·MapNames·map,·GameModes·gameMode,·string·roomCode,·string·serverName,·IGameOptions·options,·List<GameData.PlayerInfo>·players)7 »       public·void·StartGame(NetworkedPlayerInfo·localPlayer,·int·playerCount,·int·impostorCount,·NetworkModes·networkMode,·MapNames·map,·GameModes·gameMode,·string·roomCode,·string·serverName,·IGameOptions·options,·List<NetworkedPlayerInfo>·players)
8 »       {8 »       {
9 »       }9 »       }
10 10
11 »       public·void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List<GameData.PlayerInfo>·players)11 »       public·void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List<NetworkedPlayerInfo>·players)
12 »       {12 »       {
13 »       }13 »       }
14 14
15 »       public·void·VentUsed(GameData.PlayerInfo·player)15 »       public·void·VentUsed(NetworkedPlayerInfo·player)
16 »       {16 »       {
17 »       }17 »       }
18 18
19 »       public·void·Kill(GameData.PlayerInfo·victim,·GameData.PlayerInfo·killer)19 »       public·void·Kill(NetworkedPlayerInfo·victim,·NetworkedPlayerInfo·killer)
20 »       {20 »       {
21 »       }21 »       }
22 22
23 »       public·void·SabotageStart(SystemTypes·type)23 »       public·void·SabotageStart(SystemTypes·type)
24 »       {24 »       {
25 »       }25 »       }
26 26
27 »       public·void·SabotageFixed(SystemTypes·type)27 »       public·void·SabotageFixed(SystemTypes·type)
28 »       {28 »       {
29 »       }29 »       }
30 30
31 »       public·void·TaskCompleted(GameData.PlayerInfo·player,·PlayerTask·task)31 »       public·void·TaskCompleted(NetworkedPlayerInfo·player,·PlayerTask·task)
32 »       {32 »       {
33 »       }33 »       }
34 34
35 »       public·void·MeetingStarted(GameData.PlayerInfo·callingPlayer,·bool·bodyReported)35 »       public·void·MeetingStarted(NetworkedPlayerInfo·callingPlayer,·bool·bodyReported)
36 »       {36 »       {
37 »       }37 »       }
38 38
39 »       public·void·MeetingEnded(float·durationInSeconds,·GameData.PlayerInfo·playerEjected)39 »       public·void·MeetingEnded(float·durationInSeconds,·NetworkedPlayerInfo·playerEjected)
40 »       {40 »       {
41 »       }41 »       }
42 42
43 »       public·void·MinigameOpened(GameData.PlayerInfo·callingPlayer,·TaskTypes·task)43 »       public·void·MinigameOpened(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task)
44 »       {44 »       {
45 »       }45 »       }
46 46
47 »       public·void·MinigameClosed(GameData.PlayerInfo·callingPlayer,·TaskTypes·task,·float·durationInSeconds,·bool·isCompleted)47 »       public·void·MinigameClosed(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task,·float·durationInSeconds,·bool·isCompleted)
48 »       {48 »       {
49 »       }49 »       }
50 }50 }
1.03 KB
Assembly-CSharp/DummyBehaviour.cs
    
Offset 7, 15 lines modifiedOffset 7, 15 lines modified
7 »       public·void·Start()7 »       public·void·Start()
8 »       {8 »       {
9 »       »       this.myPlayer·=·base.GetComponent<PlayerControl>();9 »       »       this.myPlayer·=·base.GetComponent<PlayerControl>();
10 »       }10 »       }
11 11
12 »       public·void·Update()12 »       public·void·Update()
13 »       {13 »       {
14 »       »       GameData.PlayerInfo·data·=·this.myPlayer.Data;14 »       »       NetworkedPlayerInfo·data·=·this.myPlayer.Data;
15 »       »       if·(data·==·null·||·data.IsDead)15 »       »       if·(data·==·null·||·data.IsDead)
16 »       »       {16 »       »       {
17 »       »       »       return;17 »       »       »       return;
18 »       »       }18 »       »       }
19 »       »       if·(MeetingHud.Instance)19 »       »       if·(MeetingHud.Instance)
20 »       »       {20 »       »       {
21 »       »       »       if·(!this.voted)21 »       »       »       if·(!this.voted)
Offset 48, 18 lines modifiedOffset 48, 18 lines modified
48 »       »       »       for·(int·i·=·0;·i·<·100;·i++)48 »       »       »       for·(int·i·=·0;·i·<·100;·i++)
49 »       »       »       {49 »       »       »       {
50 »       »       »       »       int·num·=·IntRange.Next(-1,·GameData.Instance.PlayerCount);50 »       »       »       »       int·num·=·IntRange.Next(-1,·GameData.Instance.PlayerCount);
51 »       »       »       »       if·(num·<·0)51 »       »       »       »       if·(num·<·0)
52 »       »       »       »       {52 »       »       »       »       {
53 »       »       »       »       »       break;53 »       »       »       »       »       break;
54 »       »       »       »       }54 »       »       »       »       }
55 »       »       »       »       GameData.PlayerInfo·playerInfo·=·GameData.Instance.AllPlayers[num];55 »       »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers[num];
56 »       »       »       »       if·(!playerInfo.IsDead)56 »       »       »       »       if·(!networkedPlayerInfo.IsDead)
57 »       »       »       »       {57 »       »       »       »       {
58 »       »       »       »       »       b·=·playerInfo.PlayerId;58 »       »       »       »       »       b·=·networkedPlayerInfo.PlayerId;
59 »       »       »       »       »       break;59 »       »       »       »       »       break;
60 »       »       »       »       }60 »       »       »       »       }
61 »       »       »       }61 »       »       »       }
62 »       »       }62 »       »       }
63 »       »       this.PlayerIdToVoteFor·=·-1;63 »       »       this.PlayerIdToVoteFor·=·-1;
64 »       »       MeetingHud.Instance.CmdCastVote(this.myPlayer.PlayerId,·b);64 »       »       MeetingHud.Instance.CmdCastVote(this.myPlayer.PlayerId,·b);
65 »       »       yield·break;65 »       »       yield·break;
6.96 KB
Assembly-CSharp/EndGameManager.cs
    
Offset 11, 108 lines modifiedOffset 11, 108 lines modified
11 {11 {
12 »       public·void·Start()12 »       public·void·Start()
13 »       {13 »       {
14 »       »       this.SetEverythingUp();14 »       »       this.SetEverythingUp();
15 »       »       base.StartCoroutine(this.CoBegin());15 »       »       base.StartCoroutine(this.CoBegin());
16 »       »       base.Invoke("ShowButtons",·1.1f);16 »       »       base.Invoke("ShowButtons",·1.1f);
17 »       »       ConsoleJoystick.SetMode_Menu();17 »       »       ConsoleJoystick.SetMode_Menu();
18 »       »       DestroyableSingleton<AchievementManager>.Instance.OnMatchEnd(TempData.EndReason,·Enumerable.Any<WinningPlayerData>(TempData.winners,·(WinningPlayerData·h)·=>·h.IsYou));18 »       »       DestroyableSingleton<AchievementManager>.Instance.OnMatchEnd(EndGameResult.CachedGameOverReason,·Enumerable.Any<CachedPlayerData>(EndGameResult.CachedWinners,·(CachedPlayerData·h)·=>·h.IsYou));
19 »       }19 »       }
20 20
21 »       private·void·ShowButtons()21 »       private·void·ShowButtons()
22 »       {22 »       {
23 »       »       this.FrontMost.gameObject.SetActive(false);23 »       »       this.FrontMost.gameObject.SetActive(false);
24 »       »       if·(TempData.XpGrantedResult.GrantedXp·>·0U·||·TempData.PodsGrantResult.GrantedPodsWithMultiplierApplied·>·0U·||·TempData.BeansGrantResult.GrantedPodsWithMultiplierApplied·>·0U)24 »       »       if·(EndGameResult.CachedXpGrantResult.GrantedXp·>·0U·||·EndGameResult.CachedPodsGrantResult.GrantedPodsWithMultiplierApplied·>·0U·||·EndGameResult.CachedBeansGrantResult.GrantedPodsWithMultiplierApplied·>·0U)
25 »       »       {25 »       »       {
26 »       »       »       this.Navigation.ShowNavigationToProgressionScreen();26 »       »       »       this.Navigation.ShowNavigationToProgressionScreen();
27 »       »       »       return;27 »       »       »       return;
28 »       »       }28 »       »       }
29 »       »       this.Navigation.ShowDefaultNavigation();29 »       »       this.Navigation.ShowDefaultNavigation();
30 »       }30 »       }
31 31
32 »       private·void·SetEverythingUp()32 »       private·void·SetEverythingUp()
33 »       {33 »       {
34 »       »       StatsManager.Instance.IncrementStat(StringNames.StatsGamesFinished);34 »       »       StatsManager.Instance.IncrementStat(StringNames.StatsGamesFinished);
35 »       »       this.Navigation.HideButtons();35 »       »       this.Navigation.HideButtons();
36 »       »       bool·flag·=·GameManager.Instance.DidHumansWin(TempData.EndReason);36 »       »       bool·flag·=·GameManager.Instance.DidHumansWin(EndGameResult.CachedGameOverReason);
37 »       »       if·(TempData.EndReason·==·GameOverReason.ImpostorDisconnect)37 »       »       if·(EndGameResult.CachedGameOverReason·==·GameOverReason.ImpostorDisconnect)
38 »       »       {38 »       »       {
39 »       »       »       StatsManager.Instance.AddDrawReason(TempData.EndReason);39 »       »       »       StatsManager.Instance.AddDrawReason(EndGameResult.CachedGameOverReason);
40 »       »       »       this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ImpostorDisconnected,·Array.Empty<object>());40 »       »       »       this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ImpostorDisconnected,·Array.Empty<object>());
41 »       »       »       SoundManager.Instance.PlaySound(this.DisconnectStinger,·false,·1f,·null);41 »       »       »       SoundManager.Instance.PlaySound(this.DisconnectStinger,·false,·1f,·null);
42 »       »       }42 »       »       }
43 »       »       else43 »       »       else
44 »       »       {44 »       »       {
45 »       »       »       if·(Enumerable.Any<WinningPlayerData>(TempData.winners,·(WinningPlayerData·h)·=>·h.IsYou))45 »       »       »       if·(Enumerable.Any<CachedPlayerData>(EndGameResult.CachedWinners,·(CachedPlayerData·h)·=>·h.IsYou))
46 »       »       »       {46 »       »       »       {
47 »       »       »       »       StatsManager.Instance.AddWinReason(TempData.EndReason,·(int)GameManager.Instance.LogicOptions.MapId,·PlayerControl.LocalPlayer.Data.RoleWhenAlive.GetValueOrDefault());47 »       »       »       »       StatsManager.Instance.AddWinReason(EndGameResult.CachedGameOverReason,·(int)GameManager.Instance.LogicOptions.MapId,·EndGameResult.CachedLocalPlayer.RoleWhenAlive);
48 »       »       »       »       DestroyableSingleton<AchievementManager>.Instance.SetWinMap((int)GameManager.Instance.LogicOptions.MapId);48 »       »       »       »       DestroyableSingleton<AchievementManager>.Instance.SetWinMap((int)GameManager.Instance.LogicOptions.MapId);
49 »       »       »       »       this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Victory,·Array.Empty<object>());49 »       »       »       »       this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Victory,·Array.Empty<object>());
50 »       »       »       »       this.BackgroundBar.material.SetColor("_Color",·Palette.CrewmateBlue);50 »       »       »       »       this.BackgroundBar.material.SetColor("_Color",·Palette.CrewmateBlue);
51 »       »       »       »       WinningPlayerData·winningPlayerData·=·Enumerable.FirstOrDefault<WinningPlayerData>(TempData.winners,·(WinningPlayerData·h)·=>·h.IsYou);51 »       »       »       »       CachedPlayerData·cachedPlayerData·=·Enumerable.FirstOrDefault<CachedPlayerData>(EndGameResult.CachedWinners,·(CachedPlayerData·h)·=>·h.IsYou);
52 »       »       »       »       if·(winningPlayerData·!=·null)52 »       »       »       »       if·(cachedPlayerData·!=·null)
53 »       »       »       »       {53 »       »       »       »       {
54 »       »       »       »       »       DestroyableSingleton<UnityTelemetry>.Instance.WonGame(winningPlayerData.ColorId,·winningPlayerData.HatId,·winningPlayerData.SkinId,·winningPlayerData.PetId,·winningPlayerData.VisorId,·winningPlayerData.NamePlateId);54 »       »       »       »       »       DestroyableSingleton<UnityTelemetry>.Instance.WonGame(cachedPlayerData.ColorId,·cachedPlayerData.HatId,·cachedPlayerData.SkinId,·cachedPlayerData.PetId,·cachedPlayerData.VisorId,·cachedPlayerData.NamePlateId);
55 »       »       »       »       }55 »       »       »       »       }
56 »       »       »       }56 »       »       »       }
57 »       »       »       else57 »       »       »       else
58 »       »       »       {58 »       »       »       {
59 »       »       »       »       StatsManager.Instance.AddLoseReason(TempData.EndReason);59 »       »       »       »       StatsManager.Instance.AddLoseReason(EndGameResult.CachedGameOverReason);
60 »       »       »       »       this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Defeat,·Array.Empty<object>());60 »       »       »       »       this.WinText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Defeat,·Array.Empty<object>());
61 »       »       »       »       this.WinText.color·=·Color.red;61 »       »       »       »       this.WinText.color·=·Color.red;
62 »       »       »       }62 »       »       »       }
63 »       »       »       if·(flag)63 »       »       »       if·(flag)
64 »       »       »       {64 »       »       »       {
65 »       »       »       »       SoundManager.Instance.PlayDynamicSound("Stinger",·this.CrewStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel);65 »       »       »       »       SoundManager.Instance.PlayDynamicSound("Stinger",·this.CrewStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel);
66 »       »       »       }66 »       »       »       }
67 »       »       »       else67 »       »       »       else
68 »       »       »       {68 »       »       »       {
69 »       »       »       »       SoundManager.Instance.PlayDynamicSound("Stinger",·this.ImpostorStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel);69 »       »       »       »       SoundManager.Instance.PlayDynamicSound("Stinger",·this.ImpostorStinger,·false,·new·DynamicSound.GetDynamicsFunction(this.GetStingerVol),·SoundManager.Instance.MusicChannel);
70 »       »       »       }70 »       »       »       }
71 »       »       }71 »       »       }
72 »       »       int·num·=·Mathf.CeilToInt(7.5f);72 »       »       int·num·=·Mathf.CeilToInt(7.5f);
73 »       »       List<WinningPlayerData>·list·=·Enumerable.ToList<WinningPlayerData>(Enumerable.OrderBy<WinningPlayerData,·int>(TempData.winners,·delegate(WinningPlayerData·b)73 »       »       List<CachedPlayerData>·list·=·Enumerable.ToList<CachedPlayerData>(Enumerable.OrderBy<CachedPlayerData,·int>(EndGameResult.CachedWinners,·delegate(CachedPlayerData·b)
74 »       »       {74 »       »       {
75 »       »       »       if·(!b.IsYou)75 »       »       »       if·(!b.IsYou)
76 »       »       »       {76 »       »       »       {
77 »       »       »       »       return·0;77 »       »       »       »       return·0;
78 »       »       »       }78 »       »       »       }
79 »       »       »       return·-1;79 »       »       »       return·-1;
80 »       »       }));80 »       »       }));
81 »       »       for·(int·i·=·0;·i·<·list.Count;·i++)81 »       »       for·(int·i·=·0;·i·<·list.Count;·i++)
82 »       »       {82 »       »       {
83 »       »       »       WinningPlayerData·winningPlayerData2·=·list[i];83 »       »       »       CachedPlayerData·cachedPlayerData2·=·list[i];
84 »       »       »       int·num2·=·((i·%·2·==·0)·?·(-1)·:·1);84 »       »       »       int·num2·=·((i·%·2·==·0)·?·(-1)·:·1);
85 »       »       »       int·num3·=·(i·+·1)·/·2;85 »       »       »       int·num3·=·(i·+·1)·/·2;
86 »       »       »       float·num4·=·(float)num3·/·(float)num;86 »       »       »       float·num4·=·(float)num3·/·(float)num;
87 »       »       »       float·num5·=·Mathf.Lerp(1f,·0.75f,·num4);87 »       »       »       float·num5·=·Mathf.Lerp(1f,·0.75f,·num4);
88 »       »       »       float·num6·=·(float)((i·==·0)·?·(-8)·:·(-1));88 »       »       »       float·num6·=·(float)((i·==·0)·?·(-8)·:·(-1));
89 »       »       »       PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform);89 »       »       »       PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform);
90 »       »       »       poolablePlayer.transform.localPosition·=·new·Vector3(1f·*·(float)num2·*·(float)num3·*·num5,·FloatRange.SpreadToEdges(-1.125f,·0f,·num3,·num),·num6·+·(float)num3·*·0.01f)·*·0.9f;90 »       »       »       poolablePlayer.transform.localPosition·=·new·Vector3(1f·*·(float)num2·*·(float)num3·*·num5,·FloatRange.SpreadToEdges(-1.125f,·0f,·num3,·num),·num6·+·(float)num3·*·0.01f)·*·0.9f;
91 »       »       »       float·num7·=·Mathf.Lerp(1f,·0.65f,·num4)·*·0.9f;91 »       »       »       float·num7·=·Mathf.Lerp(1f,·0.65f,·num4)·*·0.9f;
92 »       »       »       Vector3·vector·=·new·Vector3(num7,·num7,·1f);92 »       »       »       Vector3·vector·=·new·Vector3(num7,·num7,·1f);
93 »       »       »       poolablePlayer.transform.localScale·=·vector;93 »       »       »       poolablePlayer.transform.localScale·=·vector;
94 »       »       »       if·(winningPlayerData2.IsDead)94 »       »       »       if·(cachedPlayerData2.IsDead)
95 »       »       »       {95 »       »       »       {
96 »       »       »       »       poolablePlayer.SetBodyAsGhost();96 »       »       »       »       poolablePlayer.SetBodyAsGhost();
97 »       »       »       »       poolablePlayer.SetDeadFlipX(i·%·2·==·0);97 »       »       »       »       poolablePlayer.SetDeadFlipX(i·%·2·==·0);
98 »       »       »       }98 »       »       »       }
99 »       »       »       else99 »       »       »       else
100 »       »       »       {100 »       »       »       {
101 »       »       »       »       poolablePlayer.SetFlipX(i·%·2·==·0);101 »       »       »       »       poolablePlayer.SetFlipX(i·%·2·==·0);
102 »       »       »       }102 »       »       »       }
103 »       »       »       poolablePlayer.UpdateFromPlayerOutfit(winningPlayerData2,·PlayerMaterial.MaskType.None,·winningPlayerData2.IsDead,·true,·null,·false);103 »       »       »       poolablePlayer.UpdateFromPlayerOutfit(cachedPlayerData2.Outfit,·PlayerMaterial.MaskType.None,·cachedPlayerData2.IsDead,·true,·null,·false);
104 »       »       »       if·(flag)104 »       »       »       if·(flag)
105 »       »       »       {105 »       »       »       {
106 »       »       »       »       poolablePlayer.ToggleName(false);106 »       »       »       »       poolablePlayer.ToggleName(false);
107 »       »       »       }107 »       »       »       }
108 »       »       »       else108 »       »       »       else
109 »       »       »       {109 »       »       »       {
110 »       »       »       »       Color·color·=·(winningPlayerData2.IsImpostor·?·Palette.ImpostorRed·:·Palette.White);110 »       »       »       »       Color·color·=·(cachedPlayerData2.IsImpostor·?·Palette.ImpostorRed·:·Palette.White);
111 »       »       »       »       poolablePlayer.SetName(winningPlayerData2.PlayerName,·vector.Inv(),·color,·-15f);111 »       »       »       »       poolablePlayer.SetName(cachedPlayerData2.PlayerName,·vector.Inv(),·color,·-15f);
112 »       »       »       »       Vector3·vector2·=·new·Vector3(0f,·-1.31f,·-0.5f);112 »       »       »       »       Vector3·vector2·=·new·Vector3(0f,·-1.31f,·-0.5f);
113 »       »       »       »       poolablePlayer.SetNamePosition(vector2);113 »       »       »       »       poolablePlayer.SetNamePosition(vector2);
114 »       »       »       »       if·(AprilFoolsMode.ShouldHorseAround()·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek)114 »       »       »       »       if·(AprilFoolsMode.ShouldHorseAround()·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek)
115 »       »       »       »       {115 »       »       »       »       {
116 »       »       »       »       »       poolablePlayer.SetBodyType(PlayerBodyTypes.Normal);116 »       »       »       »       »       poolablePlayer.SetBodyType(PlayerBodyTypes.Normal);
117 »       »       »       »       »       poolablePlayer.SetFlipX(false);117 »       »       »       »       »       poolablePlayer.SetFlipX(false);
118 »       »       »       »       }118 »       »       »       »       }
632 B
Assembly-CSharp/EndGameNavigation.cs
    
Offset 29, 17 lines modifiedOffset 29, 17 lines modified
29 »       »       this.ContinueButton.SetActive(false);29 »       »       this.ContinueButton.SetActive(false);
30 »       }30 »       }
31 31
32 »       public·void·NextGame()32 »       public·void·NextGame()
33 »       {33 »       {
34 »       »       this.PlayAgainButton.gameObject.SetActive(false);34 »       »       this.PlayAgainButton.gameObject.SetActive(false);
35 »       »       this.ExitButton.gameObject.SetActive(false);35 »       »       this.ExitButton.gameObject.SetActive(false);
36 »       »       if·(TempData.showAd·&&·!DataManager.Player.Ads.HasPurchasedAdRemoval)36 »       »       if·(EndGameResult.CachedShowAd·&&·!DataManager.Player.Ads.HasPurchasedAdRemoval)
37 »       »       {37 »       »       {
38 »       »       »       TempData.showAd·=·false;38 »       »       »       EndGameResult.CachedShowAd·=·false;
39 »       »       }39 »       »       }
40 »       »       GameManager.DestroyInstance();40 »       »       GameManager.DestroyInstance();
41 »       »       base.StartCoroutine(this.CoJoinGame());41 »       »       base.StartCoroutine(this.CoJoinGame());
42 »       }42 »       }
43 43
44 »       public·void·Exit()44 »       public·void·Exit()
45 »       {45 »       {
3.75 KB
Assembly-CSharp/EndGameResult.cs
    
Offset 1, 28 lines modifiedOffset 1, 37 lines modified
1 using·System;1 using·System;
 2 using·System.Collections.Generic;
2 using·Hazel;3 using·Hazel;
3 4
4 public·class·EndGameResult5 public·class·EndGameResult
5 {6 {
6 »       public·EndGameResult(GameOverReason·gameOverReason,·bool·showAd,·ProgressionManager.XpGrantResult·xpGrantResult,·ProgressionManager.CurrencyGrantResult·podsGrantResult,·ProgressionManager.CurrencyGrantResult·beansGrantResult)7 »       private·EndGameResult(GameOverReason·gameOverReason,·bool·showAd,·ProgressionManager.XpGrantResult·xpGrantResult·=·null,·ProgressionManager.CurrencyGrantResult·podsGrantResult·=·null,·ProgressionManager.CurrencyGrantResult·beansGrantResult·=·null)
7 »       {8 »       {
8 »       »       this.GameOverReason·=·gameOverReason;9 »       »       this.GameOverReason·=·gameOverReason;
9 »       »       this.ShowAd·=·showAd;10 »       »       this.ShowAd·=·showAd;
10 »       »       this.XpGrantResult·=·xpGrantResult;11 »       »       this.XpGrantResult·=·xpGrantResult;
11 »       »       this.BeansGrantResult·=·beansGrantResult; 
12 »       »       this.PodsGrantResult·=·podsGrantResult;12 »       »       this.PodsGrantResult·=·podsGrantResult;
 13 »       »       this.BeansGrantResult·=·beansGrantResult;
 14 »       »       EndGameResult.ResetCachedValues();
 15 »       »       EndGameResult.CachedGameOverReason·=·this.GameOverReason;
 16 »       »       EndGameResult.CachedShowAd·=·this.ShowAd;
 17 »       »       EndGameResult.CachedXpGrantResult·=·this.XpGrantResult;
 18 »       »       EndGameResult.CachedPodsGrantResult·=·this.PodsGrantResult;
 19 »       »       EndGameResult.CachedBeansGrantResult·=·this.BeansGrantResult;
13 »       }20 »       }
14 21
15 »       public·EndGameResult(GameOverReason·gameOverReason,·bool·showAd)22 »       public·static·void·ResetCachedValues()
16 »       {23 »       {
17 »       »       this.GameOverReason·=·gameOverReason; 
18 »       »       this.ShowAd·=·showAd; 
19 »       »       this.XpGrantResult·=·null; 
20 »       »       this.BeansGrantResult·=·null; 
21 »       »       this.PodsGrantResult·=·null;24 »       »       EndGameResult.CachedWinners.Clear();
 25 »       »       EndGameResult.CachedLocalPlayer·=·null;
 26 »       »       EndGameResult.CachedGameOverReason·=·GameOverReason.HumansByTask;
 27 »       »       EndGameResult.CachedShowAd·=·false;
 28 »       »       EndGameResult.CachedXpGrantResult·=·null;
 29 »       »       EndGameResult.CachedPodsGrantResult·=·null;
 30 »       »       EndGameResult.CachedBeansGrantResult·=·null;
22 »       }31 »       }
23 32
24 »       public·static·EndGameResult·Create(MessageReader·reader)33 »       public·static·EndGameResult·Create(MessageReader·reader)
25 »       {34 »       {
26 »       »       GameOverReason·gameOverReason·=·(GameOverReason)reader.ReadByte();35 »       »       GameOverReason·gameOverReason·=·(GameOverReason)reader.ReadByte();
27 »       »       bool·flag·=·reader.ReadBoolean();36 »       »       bool·flag·=·reader.ReadBoolean();
28 »       »       if·(reader.Position·<·reader.Length)37 »       »       if·(reader.Position·<·reader.Length)
Offset 54, 20 lines modifiedOffset 63, 34 lines modified
54 »       »       »       »       }63 »       »       »       »       }
55 »       »       »       »       ProgressionManager.XpGrantResult·xpGrantResult·=·new·ProgressionManager.XpGrantResult(num2,·num,·num3,·num11,·flag2,·num4,·num5,·num6);64 »       »       »       »       ProgressionManager.XpGrantResult·xpGrantResult·=·new·ProgressionManager.XpGrantResult(num2,·num,·num3,·num11,·flag2,·num4,·num5,·num6);
56 »       »       »       »       ProgressionManager.CurrencyGrantResult·currencyGrantResult·=·new·ProgressionManager.CurrencyGrantResult(text,·(uint)DestroyableSingleton<InventoryManager>.Instance.GetPodCount(text),·num7,·num9);65 »       »       »       »       ProgressionManager.CurrencyGrantResult·currencyGrantResult·=·new·ProgressionManager.CurrencyGrantResult(text,·(uint)DestroyableSingleton<InventoryManager>.Instance.GetPodCount(text),·num7,·num9);
57 »       »       »       »       ProgressionManager.CurrencyGrantResult·currencyGrantResult2·=·new·ProgressionManager.CurrencyGrantResult(Constants.Beans,·(uint)DestroyableSingleton<InventoryManager>.Instance.UnusedBeans,·num8,·num10);66 »       »       »       »       ProgressionManager.CurrencyGrantResult·currencyGrantResult2·=·new·ProgressionManager.CurrencyGrantResult(Constants.Beans,·(uint)DestroyableSingleton<InventoryManager>.Instance.UnusedBeans,·num8,·num10);
58 »       »       »       »       return·new·EndGameResult(gameOverReason,·flag,·xpGrantResult,·currencyGrantResult,·currencyGrantResult2);67 »       »       »       »       return·new·EndGameResult(gameOverReason,·flag,·xpGrantResult,·currencyGrantResult,·currencyGrantResult2);
59 »       »       »       }68 »       »       »       }
60 »       »       }69 »       »       }
61 »       »       return·new·EndGameResult(gameOverReason,·flag);70 »       »       return·new·EndGameResult(gameOverReason,·flag,·null,·null,·null);
62 »       }71 »       }
63 72
 73 »       public·static·List<CachedPlayerData>·CachedWinners·=·new·List<CachedPlayerData>();
 74
 75 »       public·static·CachedPlayerData·CachedLocalPlayer;
 76
 77 »       public·static·GameOverReason·CachedGameOverReason·=·GameOverReason.HumansByTask;
 78
 79 »       public·static·bool·CachedShowAd;
 80
 81 »       public·static·ProgressionManager.XpGrantResult·CachedXpGrantResult;
 82
 83 »       public·static·ProgressionManager.CurrencyGrantResult·CachedBeansGrantResult;
 84
 85 »       public·static·ProgressionManager.CurrencyGrantResult·CachedPodsGrantResult;
 86
64 »       public·readonly·GameOverReason·GameOverReason;87 »       public·readonly·GameOverReason·GameOverReason;
65 88
66 »       public·readonly·bool·ShowAd;89 »       public·readonly·bool·ShowAd;
67 90
68 »       public·readonly·ProgressionManager.XpGrantResult·XpGrantResult;91 »       public·readonly·ProgressionManager.XpGrantResult·XpGrantResult;
69 92
70 »       public·readonly·ProgressionManager.CurrencyGrantResult·BeansGrantResult; 
71  
72 »       public·readonly·ProgressionManager.CurrencyGrantResult·PodsGrantResult;93 »       public·readonly·ProgressionManager.CurrencyGrantResult·PodsGrantResult;
 94
 95 »       public·readonly·ProgressionManager.CurrencyGrantResult·BeansGrantResult;
73 }96 }
575 B
Assembly-CSharp/EngineerRole.cs
    
Offset 43, 15 lines modifiedOffset 43, 15 lines modified
43 43
44 »       public·override·bool·CanUse(IUsable·console)44 »       public·override·bool·CanUse(IUsable·console)
45 »       {45 »       {
46 »       »       if·(console·is·Vent)46 »       »       if·(console·is·Vent)
47 »       »       {47 »       »       {
48 »       »       »       return·(!this.IsAffectedByComms·||·this.Player.inVent)·&&·this.usesRemaining·>·0;48 »       »       »       return·(!this.IsAffectedByComms·||·this.Player.inVent)·&&·this.usesRemaining·>·0;
49 »       »       }49 »       »       }
50 »       »       return·console·is·Console;50 »       »       return·console·is·ZiplineConsole·||·console·is·Ladder·||·console·is·PlatformConsole·||·console·is·Console·||·console·is·DoorConsole;
51 »       }51 »       }
52 52
53 »       public·override·bool·DidWin(GameOverReason·gameOverReason)53 »       public·override·bool·DidWin(GameOverReason·gameOverReason)
54 »       {54 »       {
55 »       »       return·GameManager.Instance.DidHumansWin(gameOverReason);55 »       »       return·GameManager.Instance.DidHumansWin(gameOverReason);
56 »       }56 »       }
57 57
8.94 KB
Assembly-CSharp/ExileController.cs
    
Offset 2, 14 lines modifiedOffset 2, 16 lines modified
2 using·System.Collections;2 using·System.Collections;
3 using·System.Linq;3 using·System.Linq;
4 using·TMPro;4 using·TMPro;
5 using·UnityEngine;5 using·UnityEngine;
6 6
7 public·abstract·class·ExileController·:·MonoBehaviour7 public·abstract·class·ExileController·:·MonoBehaviour
8 {8 {
 9 »       public·event·Action·OnCompleteEvent;
 10
9 »       private·void·Awake()11 »       private·void·Awake()
10 »       {12 »       {
11 »       »       this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>();13 »       »       this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>();
12 »       }14 »       }
13 15
14 »       protected·abstract·IEnumerator·Animate();16 »       protected·abstract·IEnumerator·Animate();
15 17
Offset 30, 112 lines modifiedOffset 32, 147 lines modified
30 »       »       »       }32 »       »       »       }
31 »       »       »       yield·return·null;33 »       »       »       yield·return·null;
32 »       »       }34 »       »       }
33 »       »       this.Text.text·=·this.completeString;35 »       »       this.Text.text·=·this.completeString;
34 »       »       yield·break;36 »       »       yield·break;
35 »       }37 »       }
36 38
37 »       public·void·Begin(GameData.PlayerInfo·exiled,·bool·tie)39 »       public·void·BeginForTesting(NetworkedPlayerInfo.PlayerOutfit·outfit,·bool·voteTie·=·false,·bool·isImpostor·=·true,·bool·confirmImpostor·=·true,·int·totalImpostorCount·=·1,·int·remainingImpostorCount·=·0)
 40 »       {
 41 »       »       this.Begin(new·ExileController.InitProperties
 42 »       »       {
 43 »       »       »       outfit·=·outfit,
 44 »       »       »       isImpostor·=·isImpostor,
 45 »       »       »       confirmImpostor·=·confirmImpostor,
 46 »       »       »       voteTie·=·voteTie,
 47 »       »       »       totalImpostorCount·=·totalImpostorCount,
 48 »       »       »       remainingImpostorCount·=·remainingImpostorCount
 49 »       »       });
 50 »       }
 51
 52 »       public·void·BeginForGameplay(NetworkedPlayerInfo·player,·bool·voteTie)
 53 »       {
 54 »       »       ExileController.InitProperties·initProperties·=·new·ExileController.InitProperties();
 55 »       »       if·(player·!=·null)
 56 »       »       {
 57 »       »       »       initProperties.outfit·=·player.Outfits[PlayerOutfitType.Default];
 58 »       »       »       initProperties.networkedPlayer·=·player;
 59 »       »       »       initProperties.isImpostor·=·player.Role.IsImpostor;
 60 »       »       }
 61 »       »       initProperties.voteTie·=·voteTie;
 62 »       »       initProperties.confirmImpostor·=·GameManager.Instance.LogicOptions.GetConfirmImpostor();
 63 »       »       initProperties.totalImpostorCount·=·Enumerable.Count<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Role.IsImpostor);
 64 »       »       initProperties.remainingImpostorCount·=·Enumerable.Count<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Role.IsImpostor·&&·!p.IsDead·&&·!p.Disconnected);
 65 »       »       if·(player·!=·null·&&·player.Role.IsImpostor·&&·!player.Disconnected)
 66 »       »       {
 67 »       »       »       initProperties.remainingImpostorCount--;
 68 »       »       }
 69 »       »       this.Begin(initProperties);
 70 »       }
 71
 72 »       private·void·Begin(ExileController.InitProperties·init)
38 »       {73 »       {
39 »       »       if·(this.specialInputHandler·!=·null)74 »       »       if·(this.specialInputHandler·!=·null)
40 »       »       {75 »       »       {
41 »       »       »       this.specialInputHandler.disableVirtualCursor·=·true;76 »       »       »       this.specialInputHandler.disableVirtualCursor·=·true;
42 »       »       }77 »       »       }
43 »       »       ExileController.Instance·=·this;78 »       »       ExileController.Instance·=·this;
44 »       »       ControllerManager.Instance.CloseAndResetAll();79 »       »       ControllerManager.Instance.CloseAndResetAll();
45 »       »       this.exiled·=·exiled;80 »       »       this.initData·=·init;
46 »       »       this.Text.gameObject.SetActive(false);81 »       »       this.Text.gameObject.SetActive(false);
47 »       »       this.Text.text·=·string.Empty;82 »       »       this.Text.text·=·string.Empty;
 83 »       »       if·(init·!=·null·&&·init.outfit·!=·null)
48 »       »       int·num·=·Enumerable.Count<GameData.PlayerInfo>(GameData.Instance.AllPlayers,·(GameData.PlayerInfo·p)·=>·p.Role.IsImpostor·&&·!p.IsDead·&&·!p.Disconnected); 
49 »       »       if·(exiled·!=·null) 
50 »       »       {84 »       »       {
 85 »       »       »       if·(!init.confirmImpostor)
51 »       »       »       int·num2·=·Enumerable.Count<GameData.PlayerInfo>(GameData.Instance.AllPlayers,·(GameData.PlayerInfo·p)·=>·p.Role.IsImpostor); 
52 »       »       »       if·(!GameManager.Instance.LogicOptions.GetConfirmImpostor()) 
53 »       »       »       {86 »       »       »       {
54 »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextNonConfirm,·new·object[]·{·exiled.PlayerName·});87 »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextNonConfirm,·new·object[]·{·init.outfit.PlayerName·});
55 »       »       »       }88 »       »       »       }
56 »       »       »       else·if·(exiled.Role.IsImpostor)89 »       »       »       else·if·(init.isImpostor)
57 »       »       »       {90 »       »       »       {
58 »       »       »       »       if·(num2·>·1)91 »       »       »       »       if·(init.totalImpostorCount·>·1)
59 »       »       »       »       {92 »       »       »       »       {
60 »       »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPP,·new·object[]·{·exiled.PlayerName·});93 »       »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPP,·new·object[]·{·init.outfit.PlayerName·});
61 »       »       »       »       }94 »       »       »       »       }
62 »       »       »       »       else95 »       »       »       »       else
63 »       »       »       »       {96 »       »       »       »       {
64 »       »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSP,·new·object[]·{·exiled.PlayerName·});97 »       »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSP,·new·object[]·{·init.outfit.PlayerName·});
65 »       »       »       »       }98 »       »       »       »       }
66 »       »       »       }99 »       »       »       }
67 »       »       »       else·if·(num2·>·1)100 »       »       »       else·if·(init.totalImpostorCount·>·1)
68 »       »       »       {101 »       »       »       {
69 »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPN,·new·object[]·{·exiled.PlayerName·});102 »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextPN,·new·object[]·{·init.outfit.PlayerName·});
70 »       »       »       }103 »       »       »       }
71 »       »       »       else104 »       »       »       else
72 »       »       »       {105 »       »       »       {
73 »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSN,·new·object[]·{·exiled.PlayerName·});106 »       »       »       »       this.completeString·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.ExileTextSN,·new·object[]·{·init.outfit.PlayerName·});
74 »       »       »       }107 »       »       »       }
75 »       »       »       this.Player.UpdateFromEitherPlayerDataOrCache(exiled,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.Exile,·false,·delegate108 »       »       »       this.Player.UpdateFromPlayerOutfit(init.outfit,·PlayerMaterial.MaskType.Exile,·false,·false,·delegate
76 »       »       »       {109 »       »       »       {
77 »       »       »       »       SkinViewData·skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin(exiled.Outfits[PlayerOutfitType.Default].SkinId);110 »       »       »       »       SkinViewData·skinViewData;
 111 »       »       »       »       if·(GameManager.Instance·!=·null)
 112 »       »       »       »       {
 113 »       »       »       »       »       skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin(this.initData.outfit.SkinId);
 114 »       »       »       »       }
 115 »       »       »       »       else
 116 »       »       »       »       {
 117 »       »       »       »       »       skinViewData·=·this.Player.GetSkinView();
 118 »       »       »       »       }
78 »       »       »       »       if·(!DestroyableSingleton<HatManager>.Instance.CheckLongModeValidCosmetic(exiled.Outfits[PlayerOutfitType.Default].SkinId,·this.Player.GetIgnoreLongMode()))119 »       »       »       »       if·(GameManager.Instance·!=·null·&&·!DestroyableSingleton<HatManager>.Instance.CheckLongModeValidCosmetic(init.outfit.SkinId,·this.Player.GetIgnoreLongMode()))
79 »       »       »       »       {120 »       »       »       »       {
80 »       »       »       »       »       skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin("skin_None");121 »       »       »       »       »       skinViewData·=·ShipStatus.Instance.CosmeticsCache.GetSkin("skin_None");
81 »       »       »       »       }122 »       »       »       »       }
82 »       »       »       »       if·(this.useIdleAnim)123 »       »       »       »       if·(this.useIdleAnim)
83 »       »       »       »       {124 »       »       »       »       {
84 »       »       »       »       »       this.Player.FixSkinSprite(skinViewData.IdleFrame);125 »       »       »       »       »       this.Player.FixSkinSprite(skinViewData.IdleFrame);
85 »       »       »       »       »       return;126 »       »       »       »       »       return;
86 »       »       »       »       }127 »       »       »       »       }
87 »       »       »       »       this.Player.FixSkinSprite(skinViewData.EjectFrame);128 »       »       »       »       this.Player.FixSkinSprite(skinViewData.EjectFrame);
88 »       »       »       });129 »       »       »       },·false);
89 »       »       »       this.Player.ToggleName(false);130 »       »       »       this.Player.ToggleName(false);
90 »       »       »       if·(!this.useIdleAnim)131 »       »       »       if·(!this.useIdleAnim)
91 »       »       »       {132 »       »       »       {
92 »       »       »       »       this.Player.SetCustomHatPosition(this.exileHatPosition);133 »       »       »       »       this.Player.SetCustomHatPosition(this.exileHatPosition);
93 »       »       »       »       this.Player.SetCustomVisorPosition(this.exileVisorPosition);134 »       »       »       »       this.Player.SetCustomVisorPosition(this.exileVisorPosition);
94 »       »       »       }135 »       »       »       }
95 »       »       »       if·(exiled.Role.IsImpostor·&&·!exiled.Disconnected) 
96 »       »       »       { 
Max diff block lines reached; 2713/9086 bytes (29.86%) of diff not shown.
1.13 KB
Assembly-CSharp/FindCritterEggMinigame.cs
Ordering differences only
    
Offset 86, 39 lines modifiedOffset 86, 39 lines modified
86 »       »       VibrationManager.Vibrate(0.3f,·0.3f,·0.1f,·VibrationManager.VibrationFalloff.None,·null,·false,·"");86 »       »       VibrationManager.Vibrate(0.3f,·0.3f,·0.1f,·VibrationManager.VibrationFalloff.None,·null,·false,·"");
87 »       »       if·(Constants.ShouldPlaySfx())87 »       »       if·(Constants.ShouldPlaySfx())
88 »       »       {88 »       »       {
89 »       »       »       SoundManager.Instance.PlaySoundImmediate(this.leafSfx.Random<AudioClip>(),·false,·1f,·Random.Range(1f·-·this.leafSfxPitchRange,·1f·+·this.leafSfxPitchRange),·null);89 »       »       »       SoundManager.Instance.PlaySoundImmediate(this.leafSfx.Random<AudioClip>(),·false,·1f,·Random.Range(1f·-·this.leafSfxPitchRange,·1f·+·this.leafSfxPitchRange),·null);
90 »       »       }90 »       »       }
91 »       }91 »       }
92 92
93 »       [Header("Egg")] 
94 »       [SerializeField]93 »       [SerializeField]
 94 »       [Header("Egg")]
95 »       private·Transform[]·spawnPoints;95 »       private·Transform[]·spawnPoints;
96 96
97 »       [SerializeField]97 »       [SerializeField]
98 »       private·Transform·egg;98 »       private·Transform·egg;
99 99
100 »       [SerializeField]100 »       [SerializeField]
101 »       private·PassiveButton·eggButton;101 »       private·PassiveButton·eggButton;
102 102
103 »       [Header("Leaves")] 
104 »       [SerializeField]103 »       [SerializeField]
 104 »       [Header("Leaves")]
105 »       private·EggCoveringLeaf[]·leaves;105 »       private·EggCoveringLeaf[]·leaves;
106 106
107 »       [SerializeField] 
108 »       [Header("Cursor")]107 »       [Header("Cursor")]
 108 »       [SerializeField]
109 »       private·Transform·hand;109 »       private·Transform·hand;
110 110
111 »       [Header("Audio")]111 »       [Header("Audio")]
112 »       [SerializeField]112 »       [SerializeField]
113 »       private·AudioClip·eggGetSfx;113 »       private·AudioClip·eggGetSfx;
114 114
 115 »       [Space(10f)]
115 »       [SerializeField]116 »       [SerializeField]
116 »       [Range(0f,·1f)]117 »       [Range(0f,·1f)]
117 »       [Space(10f)] 
118 »       private·float·leafSfxPitchRange·=·0.2f;118 »       private·float·leafSfxPitchRange·=·0.2f;
119 119
120 »       [SerializeField]120 »       [SerializeField]
121 »       private·AudioClip[]·leafSfx;121 »       private·AudioClip[]·leafSfx;
122 122
123 »       private·Controller·controller·=·new·Controller();123 »       private·Controller·controller·=·new·Controller();
124 124
475 B
Assembly-CSharp/FlatWaveBehaviour.cs
Ordering differences only
    
Offset 1, 12 lines modifiedOffset 1, 12 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 [RequireComponent(typeof(MeshRenderer))] 
5 [RequireComponent(typeof(MeshFilter))]4 [RequireComponent(typeof(MeshFilter))]
 5 [RequireComponent(typeof(MeshRenderer))]
6 public·class·FlatWaveBehaviour·:·MonoBehaviour6 public·class·FlatWaveBehaviour·:·MonoBehaviour
7 {7 {
8 »       public·void·Start()8 »       public·void·Start()
9 »       {9 »       {
10 »       »       this.mesh·=·new·Mesh();10 »       »       this.mesh·=·new·Mesh();
11 »       »       base.GetComponent<MeshFilter>().mesh·=·this.mesh;11 »       »       base.GetComponent<MeshFilter>().mesh·=·this.mesh;
12 »       »       this.mesh.MarkDynamic();12 »       »       this.mesh.MarkDynamic();
388 B
Assembly-CSharp/FreeplayPopover.cs
Ordering differences only
    
Offset 56, 11 lines modifiedOffset 56, 11 lines modified
56 »       [SerializeField]56 »       [SerializeField]
57 »       private·FreeplayPopoverButton[]·buttons;57 »       private·FreeplayPopoverButton[]·buttons;
58 58
59 »       [Space(10f)]59 »       [Space(10f)]
60 »       [SerializeField]60 »       [SerializeField]
61 »       private·HostLocalGameButton·hostGameButton;61 »       private·HostLocalGameButton·hostGameButton;
62 62
63 »       [SerializeField] 
64 »       [Header("Console·Controller·Navigation")]63 »       [Header("Console·Controller·Navigation")]
 64 »       [SerializeField]
65 »       private·UiElement·backButton;65 »       private·UiElement·backButton;
66 }66 }
2.13 KB
Assembly-CSharp/FriendsListButton.cs
    
Offset 14, 33 lines modifiedOffset 14, 20 lines modified
14 »       private·void·OnDestroy()14 »       private·void·OnDestroy()
15 »       {15 »       {
16 »       »       SceneManager.sceneLoaded·-=·this.OnSceneLoaded;16 »       »       SceneManager.sceneLoaded·-=·this.OnSceneLoaded;
17 »       }17 »       }
18 18
19 »       private·void·OnSceneLoaded(Scene·scene,·LoadSceneMode·mode)19 »       private·void·OnSceneLoaded(Scene·scene,·LoadSceneMode·mode)
20 »       {20 »       {
21 »       »       this.showInScene·=·scene.name·==·"MainMenu"·||·scene.name·==·"MatchMaking"·||·scene.name·==·"MMOnline"·||·scene.name·==·"OnlineGame";21 »       »       this.showInScene·=·scene.name·==·"OnlineGame";
22 »       »       if·(scene.name·==·"OnlineGame")22 »       »       if·(scene.name·==·"OnlineGame")
23 »       »       {23 »       »       {
24 »       »       »       this.Tab.SetActive(false); 
25 »       »       »       this.NormalCollider.enabled·=·true; 
26 »       »       »       this.TabCollider.enabled·=·false; 
27 »       »       »       base.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);24 »       »       »       base.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);
28 »       »       »       DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);25 »       »       »       DestroyableSingleton<FriendsListManager>.Instance.Ui.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);
29 »       »       »       DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);26 »       »       »       DestroyableSingleton<FriendsListManager>.Instance.ConfirmationScreen.gameObject.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);
30 »       »       »       this.AspectPosition.DistanceFromEdge·=·this.LobbyPosition; 
31 »       »       »       this.AspectPosition.Alignment·=·AspectPosition.EdgeAlignments.RightTop; 
32 »       »       } 
33 »       »       else 
34 »       »       { 
35 »       »       »       this.NormalCollider.enabled·=·false; 
36 »       »       »       this.TabCollider.enabled·=·true; 
37 »       »       »       this.Tab.SetActive(true); 
38 »       »       »       this.AspectPosition.DistanceFromEdge·=·this.NormalPosition; 
39 »       »       »       this.AspectPosition.Alignment·=·AspectPosition.EdgeAlignments.LeftTop; 
40 »       »       }27 »       »       }
41 »       »       base.gameObject.transform.position·=·Vector3.zero;28 »       »       base.gameObject.transform.position·=·Vector3.zero;
42 »       }29 »       }
43 30
44 »       private·void·Update()31 »       private·void·Update()
45 »       {32 »       {
46 »       »       if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.Offline·||·!this.showInScene·||·ShipStatus.Instance·!=·null)33 »       »       if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.Offline·||·!this.showInScene·||·ShipStatus.Instance·!=·null)
Offset 71, 28 lines modifiedOffset 58, 16 lines modified
71 »       »       »       return;58 »       »       »       return;
72 »       »       }59 »       »       }
73 »       »       this.gamepadButton.SetColor(Palette.EnabledColor);60 »       »       this.gamepadButton.SetColor(Palette.EnabledColor);
74 »       }61 »       }
75 62
76 »       public·GameObject·Button;63 »       public·GameObject·Button;
77 64
78 »       public·AspectPosition·AspectPosition; 
79  
80 »       public·Vector3·NormalPosition; 
81  
82 »       public·Vector3·LobbyPosition; 
83  
84 »       public·TextMeshPro·NotifCount;65 »       public·TextMeshPro·NotifCount;
85 66
86 »       public·GameObject·NotifCircle;67 »       public·GameObject·NotifCircle;
87 68
88 »       public·GameObject·Tab; 
89  
90 »       public·Collider2D·TabCollider; 
91  
92 »       public·Collider2D·NormalCollider; 
93  
94 »       [SerializeField]69 »       [SerializeField]
95 »       private·ActionMapGlyphDisplay·gamepadButton;70 »       private·ActionMapGlyphDisplay·gamepadButton;
96 71
97 »       private·bool·showInScene;72 »       private·bool·showInScene;
98 }73 }
5.71 KB
Assembly-CSharp/FriendsListManager.cs
    
Offset 234, 45 lines modifiedOffset 234, 49 lines modified
234 »       »       if·(this.pollingRoutine·!=·null)234 »       »       if·(this.pollingRoutine·!=·null)
235 »       »       {235 »       »       {
236 »       »       »       base.StopCoroutine(this.pollingRoutine);236 »       »       »       base.StopCoroutine(this.pollingRoutine);
237 »       »       »       this.pollingRoutine·=·null;237 »       »       »       this.pollingRoutine·=·null;
238 »       »       }238 »       »       }
239 »       }239 »       }
240 240
241 »       public·void·SetRecentlyPlayed(List<GameData.PlayerInfo>·players)241 »       public·void·SetRecentlyPlayed(List<NetworkedPlayerInfo>·players)
242 »       {242 »       {
243 »       »       this.RecentlyPlayedWith·=·players;243 »       »       this.RecentlyPlayedWith·=·new·List<FriendsListManager.RecentPlayedWithPlayer>();
 244 »       »       foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·players)
 245 »       »       {
 246 »       »       »       this.RecentlyPlayedWith.Add(new·FriendsListManager.RecentPlayedWithPlayer(networkedPlayerInfo));
 247 »       »       }
244 »       »       this.UpdateFriendsDataWithPlayers(players);248 »       »       this.UpdateFriendsDataWithPlayers(players);
245 »       }249 »       }
246 250
247 »       public·void·UpdateFriendsDataWithPlayers(List<GameData.PlayerInfo>·players)251 »       public·void·UpdateFriendsDataWithPlayers(List<NetworkedPlayerInfo>·players)
248 »       {252 »       {
249 »       »       if·(players·==·null·||·players.Count·==·0)253 »       »       if·(players·==·null·||·players.Count·==·0)
250 »       »       {254 »       »       {
251 »       »       »       return;255 »       »       »       return;
252 »       »       }256 »       »       }
253 »       »       bool·flag·=·false;257 »       »       bool·flag·=·false;
254 »       »       StringBuilder·stringBuilder·=·new·StringBuilder(string.Format("Updating·{0}·with·player·info·from·{1}·players!)",·"PlayerFriendData",·players.Count));258 »       »       StringBuilder·stringBuilder·=·new·StringBuilder(string.Format("Updating·{0}·with·player·info·from·{1}·players!)",·"PlayerFriendData",·players.Count));
255 »       »       foreach·(GameData.PlayerInfo·playerInfo·in·players)259 »       »       foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·players)
256 »       »       {260 »       »       {
257 »       »       »       if·(playerInfo·==·null·||·string.IsNullOrWhiteSpace(playerInfo.PlayerName)·||·string.IsNullOrWhiteSpace(playerInfo.Puid)·||·playerInfo.IsIncomplete)261 »       »       »       if·(networkedPlayerInfo·==·null·||·string.IsNullOrWhiteSpace(networkedPlayerInfo.PlayerName)·||·string.IsNullOrWhiteSpace(networkedPlayerInfo.Puid)·||·networkedPlayerInfo.IsIncomplete)
258 »       »       »       {262 »       »       »       {
259 »       »       »       »       stringBuilder.AppendLine("·-·Player·"·+·"[Uninitialized]".Color(Palette.LogErrorColor));263 »       »       »       »       stringBuilder.AppendLine("·-·Player·"·+·"[Uninitialized]".Color(Palette.LogErrorColor));
260 »       »       »       }264 »       »       »       }
261 »       »       »       else265 »       »       »       else
262 »       »       »       {266 »       »       »       {
263 »       »       »       »       stringBuilder.AppendLine(string.Concat(new·string[]·{·"·-·",·playerInfo.PlayerName,·"·(PUID:·",·playerInfo.Puid,·")·"·}));267 »       »       »       »       stringBuilder.AppendLine(string.Concat(new·string[]·{·"·-·",·networkedPlayerInfo.PlayerName,·"·(PUID:·",·networkedPlayerInfo.Puid,·")·"·}));
264 »       »       »       »       if·(this.IsPlayerFriend(playerInfo.Puid))268 »       »       »       »       if·(this.IsPlayerFriend(networkedPlayerInfo.Puid))
265 »       »       »       »       {269 »       »       »       »       {
266 »       »       »       »       »       stringBuilder.Append("[Friend]·".Color(Palette.LogSuccessColor));270 »       »       »       »       »       stringBuilder.Append("[Friend]·".Color(Palette.LogSuccessColor));
267 »       »       »       »       »       string·cachedName·=·DataManager.Player.Friends.GetCachedName(playerInfo.Puid);271 »       »       »       »       »       string·cachedName·=·DataManager.Player.Friends.GetCachedName(networkedPlayerInfo.Puid);
268 »       »       »       »       »       if·(string.IsNullOrWhiteSpace(cachedName)·||·cachedName·!=·playerInfo.PlayerName)272 »       »       »       »       »       if·(string.IsNullOrWhiteSpace(cachedName)·||·cachedName·!=·networkedPlayerInfo.PlayerName)
269 »       »       »       »       »       {273 »       »       »       »       »       {
270 »       »       »       »       »       »       stringBuilder.Append("[Cached·new·name]".Color(Palette.LogWarningColor));274 »       »       »       »       »       »       stringBuilder.Append("[Cached·new·name]".Color(Palette.LogWarningColor));
271 »       »       »       »       »       »       DataManager.Player.Friends.UpdateCachedName(playerInfo.Puid,·playerInfo.PlayerName);275 »       »       »       »       »       »       DataManager.Player.Friends.UpdateCachedName(networkedPlayerInfo.Puid,·networkedPlayerInfo.PlayerName);
272 »       »       »       »       »       »       flag·=·true;276 »       »       »       »       »       »       flag·=·true;
273 »       »       »       »       »       }277 »       »       »       »       »       }
274 »       »       »       »       }278 »       »       »       »       }
275 »       »       »       }279 »       »       »       }
276 »       »       }280 »       »       }
277 »       »       if·(flag)281 »       »       if·(flag)
278 »       »       {282 »       »       {
Offset 301, 14 lines modifiedOffset 305, 40 lines modified
301 »       }305 »       }
302 306
303 »       public·void·OpenUi()307 »       public·void·OpenUi()
304 »       {308 »       {
305 »       »       this.Ui.Open();309 »       »       this.Ui.Open();
306 »       }310 »       }
307 311
 312 »       public·void·CloseUI()
 313 »       {
 314 »       »       if·(this.Ui·&&·this.Ui.gameObject.activeSelf)
 315 »       »       {
 316 »       »       »       this.Ui.Close(true);
 317 »       »       }
 318 »       }
 319
 320 »       public·void·JoinGameViaFriendInvite(string·roomCode)
 321 »       {
 322 »       »       base.StartCoroutine(this.CoJoinGameViaFriendInvite(roomCode));
 323 »       }
 324
 325 »       private·IEnumerator·CoJoinGameViaFriendInvite(string·roomCode)
 326 »       {
 327 »       »       this.LoadScreen.enabled·=·true;
 328 »       »       if·(AmongUsClient.Instance.AmClient)
 329 »       »       {
 330 »       »       »       AmongUsClient.Instance.ExitGame(DisconnectReasons.ExitGame);
 331 »       »       }
 332 »       »       int·num·=·GameCode.GameNameToInt(roomCode);
 333 »       »       yield·return·AmongUsClient.Instance.CoJoinOnlineGameFromCode(num);
 334 »       »       this.LoadScreen.enabled·=·false;
 335 »       »       yield·break;
 336 »       }
 337
308 »       public·IEnumerator·CheckFriendCodeOnLogin()338 »       public·IEnumerator·CheckFriendCodeOnLogin()
309 »       {339 »       {
310 »       »       if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.LoggedIn)340 »       »       if·(DataManager.Player.Account.LoginStatus·==·EOSManager.AccountLoginStatus.LoggedIn)
311 »       »       {341 »       »       {
312 »       »       »       yield·return·base.StartCoroutine(DestroyableSingleton<FriendsListManager>.Instance.GetFriendCode(delegate(ResponseState·cb,·Response<ResponseFriendCode>·response)342 »       »       »       yield·return·base.StartCoroutine(DestroyableSingleton<FriendsListManager>.Instance.GetFriendCode(delegate(ResponseState·cb,·Response<ResponseFriendCode>·response)
313 »       »       »       {343 »       »       »       {
314 »       »       »       »       if·(cb·==·ResponseState.Success)344 »       »       »       »       if·(cb·==·ResponseState.Success)
Offset 388, 15 lines modifiedOffset 418, 15 lines modified
388 »       »       base.StartCoroutine(this.ConfirmationScreen.WaitForConfirm(confirm,·type,·recipientFriendCode));418 »       »       base.StartCoroutine(this.ConfirmationScreen.WaitForConfirm(confirm,·type,·recipientFriendCode));
389 »       }419 »       }
390 420
391 »       private·IEnumerator·PollForRequests()421 »       private·IEnumerator·PollForRequests()
392 »       {422 »       {
393 »       »       for·(;;)423 »       »       for·(;;)
394 »       »       {424 »       »       {
395 »       »       »       FriendsListManager.<>c__DisplayClass51_0·CS$<>8__locals1·=·new·FriendsListManager.<>c__DisplayClass51_0();425 »       »       »       FriendsListManager.<>c__DisplayClass55_0·CS$<>8__locals1·=·new·FriendsListManager.<>c__DisplayClass55_0();
396 »       »       »       CS$<>8__locals1.<>4__this·=·this;426 »       »       »       CS$<>8__locals1.<>4__this·=·this;
397 »       »       »       while·(!DataManager.Settings.Multiplayer.AllowFriendInvites)427 »       »       »       while·(!DataManager.Settings.Multiplayer.AllowFriendInvites)
398 »       »       »       {428 »       »       »       {
399 »       »       »       »       yield·return·null;429 »       »       »       »       yield·return·null;
400 »       »       »       }430 »       »       »       }
401 »       »       »       this.gotFriendRequests·=·false;431 »       »       »       this.gotFriendRequests·=·false;
402 »       »       »       this.gotLobbyInvites·=·false;432 »       »       »       this.gotLobbyInvites·=·false;
Offset 849, 15 lines modifiedOffset 879, 15 lines modified
849 879
850 »       public·List<ResponseBlockedBy>·BlockedByPlayers·=·new·List<ResponseBlockedBy>();880 »       public·List<ResponseBlockedBy>·BlockedByPlayers·=·new·List<ResponseBlockedBy>();
851 881
852 »       public·List<ResponseReceivedFriendRequest>·ReceivedRequests·=·new·List<ResponseReceivedFriendRequest>();882 »       public·List<ResponseReceivedFriendRequest>·ReceivedRequests·=·new·List<ResponseReceivedFriendRequest>();
853 883
854 »       public·List<LobbyInvite>·ReceivedLobbyInvites·=·new·List<LobbyInvite>();884 »       public·List<LobbyInvite>·ReceivedLobbyInvites·=·new·List<LobbyInvite>();
855 885
856 »       public·List<GameData.PlayerInfo>·RecentlyPlayedWith·=·new·List<GameData.PlayerInfo>();886 »       public·List<FriendsListManager.RecentPlayedWithPlayer>·RecentlyPlayedWith·=·new·List<FriendsListManager.RecentPlayedWithPlayer>();
857 887
858 »       public·FriendListNotification·FriendListNotification;888 »       public·FriendListNotification·FriendListNotification;
859 889
860 »       public·FriendsListConfirmMenu·ConfirmationScreen;890 »       public·FriendsListConfirmMenu·ConfirmationScreen;
861 891
862 »       public·FriendsListUI·Ui;892 »       public·FriendsListUI·Ui;
863 893
Offset 945, 8 lines modifiedOffset 975, 24 lines modified
945 975
946 »       »       public·string·Username;976 »       »       public·string·Username;
947 977
948 »       »       public·ulong·GUID;978 »       »       public·ulong·GUID;
Max diff block lines reached; 399/5774 bytes (6.91%) of diff not shown.
2.2 KB
Assembly-CSharp/FriendsListUI.cs
    
Offset 389, 15 lines modifiedOffset 389, 15 lines modified
389 »       »       if·(GameData.Instance·==·null·||·GameData.Instance.AllPlayers.Count·==·0)389 »       »       if·(GameData.Instance·==·null·||·GameData.Instance.AllPlayers.Count·==·0)
390 »       »       {390 »       »       {
391 »       »       »       return;391 »       »       »       return;
392 »       »       }392 »       »       }
393 »       »       int·num·=·0;393 »       »       int·num·=·0;
394 »       »       for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++)394 »       »       for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++)
395 »       »       {395 »       »       {
396 »       »       »       GameData.PlayerInfo·player·=·GameData.Instance.AllPlayers[i];396 »       »       »       NetworkedPlayerInfo·player·=·GameData.Instance.AllPlayers[i];
397 »       »       »       if·(player.PlayerId·!=·PlayerControl.LocalPlayer.PlayerId)397 »       »       »       if·(player.PlayerId·!=·PlayerControl.LocalPlayer.PlayerId)
398 »       »       »       {398 »       »       »       {
399 »       »       »       »       float·num2·=·this.YStart·-·(float)num·*·this.YOffset;399 »       »       »       »       float·num2·=·this.YStart·-·(float)num·*·this.YOffset;
400 »       »       »       »       LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.LobbyPlayerArea.transform);400 »       »       »       »       LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.LobbyPlayerArea.transform);
401 »       »       »       »       lobbyPlayerBar.SetUp(player.Puid,·this,·player.FriendCode,·player.PlayerName);401 »       »       »       »       lobbyPlayerBar.SetUp(player.Puid,·this,·player.FriendCode,·player.PlayerName);
402 »       »       »       »       lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f);402 »       »       »       »       lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f);
403 »       »       »       »       lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b)403 »       »       »       »       lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b)
Offset 429, 20 lines modifiedOffset 429, 20 lines modified
429 »       }429 »       }
430 430
431 »       public·void·RefreshRecentlyPlayed()431 »       public·void·RefreshRecentlyPlayed()
432 »       {432 »       {
433 »       »       int·num·=·0;433 »       »       int·num·=·0;
434 »       »       for·(int·i·=·0;·i·<·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith.Count;·i++)434 »       »       for·(int·i·=·0;·i·<·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith.Count;·i++)
435 »       »       {435 »       »       {
436 »       »       »       GameData.PlayerInfo·playerInfo·=·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith[i];436 »       »       »       FriendsListManager.RecentPlayedWithPlayer·recentPlayedWithPlayer·=·DestroyableSingleton<FriendsListManager>.Instance.RecentlyPlayedWith[i];
437 »       »       »       if·(!(playerInfo.PlayerName·==·PlayerControl.LocalPlayer.Data.PlayerName))437 »       »       »       if·(!(recentPlayedWithPlayer.PlayerName·==·DataManager.Player.Customization.Name))
438 »       »       »       {438 »       »       »       {
439 »       »       »       »       float·num2·=·this.YStart·-·(float)num·*·this.YOffset;439 »       »       »       »       float·num2·=·this.YStart·-·(float)num·*·this.YOffset;
440 »       »       »       »       LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.RecentlyPlayedArea.transform);440 »       »       »       »       LobbyPlayerBar·lobbyPlayerBar·=·Object.Instantiate<LobbyPlayerBar>(this.LobbyPlayerBar,·this.RecentlyPlayedArea.transform);
441 »       »       »       »       lobbyPlayerBar.SetUp(playerInfo.Puid,·this,·playerInfo.FriendCode,·playerInfo.PlayerName);441 »       »       »       »       lobbyPlayerBar.SetUp(recentPlayedWithPlayer.Puid,·this,·recentPlayedWithPlayer.FriendCode,·recentPlayedWithPlayer.PlayerName);
442 »       »       »       »       lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f);442 »       »       »       »       lobbyPlayerBar.transform.localPosition·=·new·Vector3(-0.29f,·num2,·-1f);
443 »       »       »       »       lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b)443 »       »       »       »       lobbyPlayerBar.Buttons.ForEach(delegate(PassiveButton·b)
444 »       »       »       »       {444 »       »       »       »       {
445 »       »       »       »       »       b.ClickMask·=·this.RecentlyPlayedScroller.Hitbox;445 »       »       »       »       »       b.ClickMask·=·this.RecentlyPlayedScroller.Hitbox;
446 »       »       »       »       });446 »       »       »       »       });
447 »       »       »       »       lobbyPlayerBar.GetAndSetPlatform();447 »       »       »       »       lobbyPlayerBar.GetAndSetPlatform();
448 »       »       »       »       this.lobbyBars.Add(lobbyPlayerBar);448 »       »       »       »       this.lobbyBars.Add(lobbyPlayerBar);
2.6 KB
Assembly-CSharp/FungleExileController.cs
    
Offset 3, 47 lines modifiedOffset 3, 57 lines modified
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·class·FungleExileController·:·ExileController5 public·class·FungleExileController·:·ExileController
6 {6 {
7 »       protected·override·IEnumerator·Animate()7 »       protected·override·IEnumerator·Animate()
8 »       {8 »       {
9 »       »       SoundManager.Instance.PlayNamedSound("ejection_beach_sfx",·this.ambience,·true,·SoundManager.Instance.SfxChannel);9 »       »       SoundManager.Instance.PlayNamedSound("ejection_beach_sfx",·this.ambience,·true,·SoundManager.Instance.SfxChannel);
10 »       »       if·(this.exiled·==·null)10 »       »       if·(this.initData·==·null·||·this.initData.outfit·==·null)
11 »       »       {11 »       »       {
12 »       »       »       this.Player.gameObject.SetActive(false);12 »       »       »       this.Player.gameObject.SetActive(false);
13 »       »       »       this.raftAnimation.gameObject.SetActive(false);13 »       »       »       this.raftAnimation.gameObject.SetActive(false);
14 »       »       }14 »       »       }
15 »       »       if·(this.exiled·!=·null·&&·this.EjectSound)15 »       »       if·(this.initData·!=·null·&&·this.initData.outfit·!=·null·&&·this.EjectSound)
16 »       »       {16 »       »       {
17 »       »       »       SoundManager.Instance.PlaySound(this.EjectSound,·false,·1f,·SoundManager.Instance.SfxChannel);17 »       »       »       SoundManager.Instance.PlaySound(this.EjectSound,·false,·1f,·SoundManager.Instance.SfxChannel);
18 »       »       }18 »       »       }
 19 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 20 »       »       {
19 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);21 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);
 22 »       »       }
20 »       »       yield·return·Effects.Wait(0.5f);23 »       »       yield·return·Effects.Wait(0.5f);
21 »       »       yield·return·Effects.All(new·IEnumerator[]24 »       »       yield·return·Effects.All(new·IEnumerator[]
22 »       »       {25 »       »       {
23 »       »       »       this.FadeBlackRaftAndPlayer(),26 »       »       »       this.FadeBlackRaftAndPlayer(),
24 »       »       »       this.HandleText(0.2f,·2f)27 »       »       »       this.HandleText(0.2f,·2f)
25 »       »       });28 »       »       });
26 »       »       if·(GameManager.Instance.LogicOptions.GetConfirmImpostor())29 »       »       if·(this.initData.confirmImpostor)
27 »       »       {30 »       »       {
28 »       »       »       this.ImpostorText.gameObject.SetActive(true);31 »       »       »       this.ImpostorText.gameObject.SetActive(true);
29 »       »       }32 »       »       }
30 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);33 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);
31 »       »       yield·return·new·WaitForSeconds(2f);34 »       »       yield·return·new·WaitForSeconds(2f);
 35 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 36 »       »       {
32 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);37 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);
 38 »       »       }
 39 »       »       else
 40 »       »       {
 41 »       »       »       yield·return·Effects.Wait(0.2f);
 42 »       »       }
33 »       »       SoundManager.Instance.StopNamedSound("ejection_beach_sfx");43 »       »       SoundManager.Instance.StopNamedSound("ejection_beach_sfx");
34 »       »       SoundManager.Instance.StopNamedSound("ejection_fire_sfx");44 »       »       SoundManager.Instance.StopNamedSound("ejection_fire_sfx");
35 »       »       base.WrapUp();45 »       »       base.WrapUp();
36 »       »       yield·break;46 »       »       yield·break;
37 »       }47 »       }
38 48
39 »       private·IEnumerator·FadeBlackRaftAndPlayer()49 »       private·IEnumerator·FadeBlackRaftAndPlayer()
40 »       {50 »       {
41 »       »       yield·return·Effects.Wait(1f);51 »       »       yield·return·Effects.Wait(1f);
42 »       »       if·(this.exiled·!=·null)52 »       »       if·(this.initData·!=·null·&&·this.initData.outfit·!=·null)
43 »       »       {53 »       »       {
44 »       »       »       this.Player.FadeBlackAll(1.5f);54 »       »       »       this.Player.FadeBlackAll(1.5f);
45 »       »       »       yield·return·Effects.ColorFade(this.raftSprite,·Color.white,·Color.black,·1.5f);55 »       »       »       yield·return·Effects.ColorFade(this.raftSprite,·Color.white,·Color.black,·1.5f);
46 »       »       »       this.fire.gameObject.SetActive(true);56 »       »       »       this.fire.gameObject.SetActive(true);
47 »       »       »       SoundManager.Instance.PlayNamedSound("ejection_fire_sfx",·this.fireSound,·true,·SoundManager.Instance.SfxChannel);57 »       »       »       SoundManager.Instance.PlayNamedSound("ejection_fire_sfx",·this.fireSound,·true,·SoundManager.Instance.SfxChannel);
48 »       »       »       VibrationManager.Vibrate(0.2f,·0.2f,·2.4f,·VibrationManager.VibrationFalloff.Linear,·null,·false,·"");58 »       »       »       VibrationManager.Vibrate(0.2f,·0.2f,·2.4f,·VibrationManager.VibrationFalloff.Linear,·null,·false,·"");
49 »       »       }59 »       »       }
475 B
Assembly-CSharp/FungleSurveillanceMinigame.cs
Ordering differences only
    
Offset 125, 16 lines modifiedOffset 125, 16 lines modified
125 125
126 »       [SerializeField]126 »       [SerializeField]
127 »       private·Vector3·initialOffset;127 »       private·Vector3·initialOffset;
128 128
129 »       [SerializeField]129 »       [SerializeField]
130 »       private·float·cameraOrthographicSize;130 »       private·float·cameraOrthographicSize;
131 131
132 »       [SerializeField] 
133 »       [Header("Speeds")]132 »       [Header("Speeds")]
 133 »       [SerializeField]
134 »       private·float·keyboardMoveSpeed;134 »       private·float·keyboardMoveSpeed;
135 135
136 »       [SerializeField]136 »       [SerializeField]
137 »       private·float·buttonMoveSpeed;137 »       private·float·buttonMoveSpeed;
138 138
139 »       [SerializeField]139 »       [SerializeField]
140 »       private·float·joystickMoveSpeed;140 »       private·float·joystickMoveSpeed;
27.4 KB
Assembly-CSharp/GameData.cs
    
Offset 1, 131 lines modifiedOffset 1, 56 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·System.Linq;3 using·System.Linq;
4 using·AmongUs.GameOptions; 
5 using·Beebyte.Obfuscator;4 using·Beebyte.Obfuscator;
6 using·Hazel; 
7 using·InnerNet;5 using·InnerNet;
8 using·UnityEngine;6 using·UnityEngine;
9 7
10 [SkipRename]8 [SkipRename]
11 public·class·GameData·:·InnerNetObject,·IDisconnectHandler9 public·class·GameData·:·MonoBehaviour,·IDisconnectHandler
12 {10 {
13 »       public·void·RpcSetTasks(byte·playerId,·byte[]·taskTypeIds)11 »       public·int·PlayerCount
14 »       {12 »       {
15 »       »       if·(AmongUsClient.Instance.AmClient)13 »       »       get
16 »       »       {14 »       »       {
17 »       »       »       this.SetTasks(playerId,·taskTypeIds);15 »       »       »       return·this.AllPlayers.Count;
18 »       »       }16 »       »       }
19 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·29,·SendOption.Reliable); 
20 »       »       messageWriter.Write(playerId); 
21 »       »       messageWriter.WriteBytesAndSize(taskTypeIds); 
22 »       »       messageWriter.EndMessage(); 
23 »       }17 »       }
24 18
25 »       public·override·bool·Serialize(MessageWriter·writer,·bool·initialState)19 »       public·bool·IsPersistent
26 »       {20 »       {
 21 »       »       get
27 »       »       List<GameData.PlayerInfo>·list·=·Enumerable.ToList<GameData.PlayerInfo>(Enumerable.OrderBy<GameData.PlayerInfo,·int>(this.AllPlayers,·delegate(GameData.PlayerInfo·p) 
28 »       »       { 
29 »       »       »       if·(!string.IsNullOrWhiteSpace(p.PlayerName)) 
30 »       »       »       { 
31 »       »       »       »       return·1; 
32 »       »       »       } 
33 »       »       »       return·0; 
34 »       »       })); 
35 »       »       int·num·=·0; 
36 »       »       for·(int·i·=·0;·i·<·list.Count;·i++) 
37 »       »       { 
38 »       »       »       GameData.PlayerInfo·playerInfo·=·list[i]; 
39 »       »       »       if·(initialState·||·base.IsDirtyBitSet((int)playerInfo.PlayerId)) 
40 »       »       »       { 
41 »       »       »       »       if·(!initialState) 
42 »       »       »       »       { 
43 »       »       »       »       »       base.UnsetDirtyBit(1U·<<·(int)playerInfo.PlayerId); 
44 »       »       »       »       } 
45 »       »       »       »       writer.StartMessage(playerInfo.PlayerId); 
46 »       »       »       »       playerInfo.Serialize(writer); 
47 »       »       »       »       writer.EndMessage(); 
48 »       »       »       »       if·(++num·>·4) 
49 »       »       »       »       { 
50 »       »       »       »       »       if·(initialState) 
51 »       »       »       »       »       { 
52 »       »       »       »       »       »       for·(int·j·=·i·+·1;·j·<·list.Count;·j++) 
53 »       »       »       »       »       »       { 
54 »       »       »       »       »       »       »       GameData.PlayerInfo·playerInfo2·=·list[j]; 
55 »       »       »       »       »       »       »       base.SetDirtyBit(1U·<<·(int)playerInfo2.PlayerId); 
56 »       »       »       »       »       »       } 
57 »       »       »       »       »       »       break; 
58 »       »       »       »       »       } 
59 »       »       »       »       »       break; 
60 »       »       »       »       } 
61 »       »       »       } 
62 »       »       } 
63 »       »       if·(num·==·0) 
64 »       »       {22 »       »       {
65 »       »       »       base.ClearDirtyBits(); 
66 »       »       »       return·false;23 »       »       »       return·true;
67 »       »       }24 »       »       }
68 »       »       return·true; 
69 »       }25 »       }
70 26
71 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)27 »       public·static·void·DestroyInstance()
72 »       {28 »       {
 29 »       »       if·(GameData.Instance·!=·null)
73 »       »       while·(reader.Position·<·reader.Length) 
74 »       »       { 
75 »       »       »       MessageReader·messageReader·=·reader.ReadMessage(); 
76 »       »       »       GameData.PlayerInfo·playerInfo·=·this.GetPlayerById(messageReader.Tag); 
77 »       »       »       if·(playerInfo·!=·null) 
78 »       »       »       { 
79 »       »       »       »       playerInfo.Deserialize(messageReader); 
80 »       »       »       } 
81 »       »       »       else 
82 »       »       »       { 
83 »       »       »       »       playerInfo·=·new·GameData.PlayerInfo(messageReader.Tag); 
84 »       »       »       »       playerInfo.Deserialize(messageReader); 
85 »       »       »       »       this.AllPlayers.Add(playerInfo); 
86 »       »       »       } 
87 »       »       } 
88 »       »       foreach·(GameData.PlayerInfo·playerInfo2·in·this.AllPlayers) 
89 »       »       {30 »       »       {
 31 »       »       »       Object.Destroy(GameData.Instance.gameObject);
90 »       »       »       ClientData·clientFromCharacter·=·AmongUsClient.Instance.GetClientFromCharacter(playerInfo2.Object); 
91 »       »       »       if·(clientFromCharacter·!=·null) 
92 »       »       »       { 
93 »       »       »       »       clientFromCharacter.UpdatePlayerName(playerInfo2.GetPlayerName(PlayerOutfitType.Default)); 
94 »       »       »       } 
95 »       »       »       if·(!playerInfo2.Role) 
96 »       »       »       { 
97 »       »       »       »       DestroyableSingleton<RoleManager>.Instance.SetRole(playerInfo2.Object,·playerInfo2.RoleType); 
98 »       »       »       } 
99 »       »       }32 »       »       }
100 »       »       this.RecomputeTaskCounts(); 
101 »       }33 »       }
102 34
103 »       public·override·void·HandleRpc(byte·callId,·MessageReader·reader)35 »       public·static·void·OnMeetingStart()
104 »       {36 »       {
 37 »       »       GameData.MeetingCount++;
105 »       »       if·(callId·==·29) 
106 »       »       { 
107 »       »       »       this.SetTasks(reader.ReadByte(),·reader.ReadBytesAndSize()); 
108 »       »       } 
109 »       }38 »       }
110 39
111 »       public·override·bool·Chunked40 »       public·static·void·OnGameEnd()
112 »       {41 »       {
 42 »       »       GameData.RoundsPlayedInSession++;
 43 »       »       GameData.MeetingCount·=·0;
 44 »       »       EndGameResult.ResetCachedValues();
113 »       »       get 
114 »       »       { 
115 »       »       »       return·true; 
116 »       »       } 
117 »       }45 »       }
118 46
119 »       public·int·PlayerCount47 »       public·static·void·OnDisconnected()
120 »       {48 »       {
Max diff block lines reached; 24135/27978 bytes (86.26%) of diff not shown.
4.3 KB
Assembly-CSharp/GameManager.cs
    
Offset 56, 15 lines modifiedOffset 56, 18 lines modified
56 »       »       »       »       flag·=·true;56 »       »       »       »       flag·=·true;
57 »       »       »       »       writer.StartMessage((byte)i);57 »       »       »       »       writer.StartMessage((byte)i);
58 »       »       »       »       gameLogicComponent.Serialize(writer,·initialState);58 »       »       »       »       gameLogicComponent.Serialize(writer,·initialState);
59 »       »       »       »       writer.EndMessage();59 »       »       »       »       writer.EndMessage();
60 »       »       »       »       gameLogicComponent.ClearDirtyFlag();60 »       »       »       »       gameLogicComponent.ClearDirtyFlag();
61 »       »       »       }61 »       »       »       }
62 »       »       }62 »       »       }
 63 »       »       if·(!initialState)
 64 »       »       {
63 »       »       base.ClearDirtyBits();65 »       »       »       base.ClearDirtyBits();
 66 »       »       }
64 »       »       return·flag;67 »       »       return·flag;
65 »       }68 »       }
66 69
67 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)70 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)
68 »       {71 »       {
69 »       »       while·(reader.Position·<·reader.Length)72 »       »       while·(reader.Position·<·reader.Length)
70 »       »       {73 »       »       {
Offset 77, 14 lines modifiedOffset 80, 22 lines modified
77 »       »       »       else80 »       »       »       else
78 »       »       »       {81 »       »       »       {
79 »       »       »       »       this.LogicComponents[tag].Deserialize(messageReader,·initialState);82 »       »       »       »       this.LogicComponents[tag].Deserialize(messageReader,·initialState);
80 »       »       »       }83 »       »       »       }
81 »       »       }84 »       »       }
82 »       }85 »       }
83 86
 87 »       public·GameSettingsCategoryList·GameSettingsList
 88 »       {
 89 »       »       get
 90 »       »       {
 91 »       »       »       return·this.gameSettingsList;
 92 »       »       }
 93 »       }
 94
84 »       public·static·GameManager·Instance·{·get;·private·set;·}95 »       public·static·GameManager·Instance·{·get;·private·set;·}
85 96
86 »       public·bool·ShouldCheckForGameEnd·{·get;·set;·}97 »       public·bool·ShouldCheckForGameEnd·{·get;·set;·}
87 98
88 »       public·bool·GameHasStarted·{·get;·set;·}99 »       public·bool·GameHasStarted·{·get;·set;·}
89 100
90 »       public·LogicGameFlow·LogicFlow·{·get;·protected·set;·}101 »       public·LogicGameFlow·LogicFlow·{·get;·protected·set;·}
Offset 105, 38 lines modifiedOffset 116, 46 lines modified
105 »       »       }116 »       »       }
106 »       }117 »       }
107 118
108 »       public·abstract·void·InitComponents();119 »       public·abstract·void·InitComponents();
109 120
110 »       public·abstract·PlayerBodyTypes·GetBodyType(PlayerControl·player);121 »       public·abstract·PlayerBodyTypes·GetBodyType(PlayerControl·player);
111 122
 123 »       public·bool·IsPersistent
 124 »       {
 125 »       »       get
 126 »       »       {
 127 »       »       »       return·false;
 128 »       »       }
 129 »       }
 130
112 »       public·virtual·void·StartGame()131 »       public·virtual·void·StartGame()
113 »       {132 »       {
114 »       »       foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents)133 »       »       foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents)
115 »       »       {134 »       »       {
116 »       »       »       gameLogicComponent.OnGameStart();135 »       »       »       gameLogicComponent.OnGameStart();
117 »       »       }136 »       »       }
118 »       »       this.ShouldCheckForGameEnd·=·true;137 »       »       this.ShouldCheckForGameEnd·=·true;
119 »       »       this.GameHasStarted·=·true;138 »       »       this.GameHasStarted·=·true;
120 »       »       foreach·(GameData.PlayerInfo·playerInfo·in·GameData.Instance.AllPlayers)139 »       »       foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers)
121 »       »       {140 »       »       {
122 »       »       »       playerInfo.OnGameStart();141 »       »       »       networkedPlayerInfo.OnGameStart();
123 »       »       }142 »       »       }
124 »       »       DestroyableSingleton<HudManager>.Instance.OnGameStart();143 »       »       DestroyableSingleton<HudManager>.Instance.OnGameStart();
125 »       }144 »       }
126 145
127 »       public·virtual·void·EndGame()146 »       public·virtual·void·EndGame()
128 »       {147 »       {
129 »       »       foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents)148 »       »       foreach·(GameLogicComponent·gameLogicComponent·in·this.LogicComponents)
130 »       »       {149 »       »       {
131 »       »       »       gameLogicComponent.OnGameEnd();150 »       »       »       gameLogicComponent.OnGameEnd();
132 »       »       }151 »       »       }
133 »       »       foreach·(GameData.PlayerInfo·playerInfo·in·GameData.Instance.AllPlayers)152 »       »       foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers)
134 »       »       {153 »       »       {
135 »       »       »       playerInfo.OnGameEnd();154 »       »       »       networkedPlayerInfo.OnGameEnd();
136 »       »       }155 »       »       }
137 »       »       this.ShouldCheckForGameEnd·=·false;156 »       »       this.ShouldCheckForGameEnd·=·false;
138 »       »       this.GameHasStarted·=·false;157 »       »       this.GameHasStarted·=·false;
139 »       }158 »       }
140 159
141 »       public·virtual·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole)160 »       public·virtual·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole)
142 »       {161 »       {
Offset 155, 14 lines modifiedOffset 174, 35 lines modified
155 »       »       »       Object.Destroy(base.gameObject);174 »       »       »       Object.Destroy(base.gameObject);
156 »       »       »       return;175 »       »       »       return;
157 »       »       }176 »       »       }
158 »       »       GameManager.Instance·=·this;177 »       »       GameManager.Instance·=·this;
159 »       »       Object.DontDestroyOnLoad(base.gameObject);178 »       »       Object.DontDestroyOnLoad(base.gameObject);
160 »       »       AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);179 »       »       AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);
161 »       »       this.InitComponents();180 »       »       this.InitComponents();
 181 »       »       this.AllGameSettingData·=·new·Dictionary<StringNames,·BaseGameSetting>();
 182 »       »       foreach·(RulesCategory·rulesCategory·in·this.gameSettingsList.AllCategories)
 183 »       »       {
 184 »       »       »       foreach·(BaseGameSetting·baseGameSetting·in·rulesCategory.AllGameSettings)
 185 »       »       »       {
 186 »       »       »       »       if·(!this.AllGameSettingData.ContainsKey(baseGameSetting.Title))
 187 »       »       »       »       {
 188 »       »       »       »       »       this.AllGameSettingData.Add(baseGameSetting.Title,·baseGameSetting);
 189 »       »       »       »       }
 190 »       »       »       }
 191 »       »       }
 192 »       »       foreach·(RoleRulesCategory·roleRulesCategory·in·this.gameSettingsList.AllRoles)
 193 »       »       {
 194 »       »       »       foreach·(BaseGameSetting·baseGameSetting2·in·roleRulesCategory.AllGameSettings)
 195 »       »       »       {
 196 »       »       »       »       if·(!this.AllGameSettingData.ContainsKey(baseGameSetting2.Title))
 197 »       »       »       »       {
 198 »       »       »       »       »       this.AllGameSettingData.Add(baseGameSetting2.Title,·baseGameSetting2);
 199 »       »       »       »       }
 200 »       »       »       }
 201 »       »       }
162 »       }202 »       }
163 203
164 »       public·bool·CheckTaskCompletion()204 »       public·bool·CheckTaskCompletion()
165 »       {205 »       {
166 »       »       if·(DestroyableSingleton<TutorialManager>.InstanceExists)206 »       »       if·(DestroyableSingleton<TutorialManager>.InstanceExists)
167 »       »       {207 »       »       {
168 »       »       »       if·(Enumerable.All<PlayerTask>(PlayerControl.LocalPlayer.myTasks,·(PlayerTask·t)·=>·t.IsComplete))208 »       »       »       if·(Enumerable.All<PlayerTask>(PlayerControl.LocalPlayer.myTasks,·(PlayerTask·t)·=>·t.IsComplete))
Offset 324, 14 lines modifiedOffset 364, 26 lines modified
324 »       »       return·false;364 »       »       return·false;
325 »       }365 »       }
Max diff block lines reached; 742/4346 bytes (17.07%) of diff not shown.
15.6 KB
Assembly-CSharp/GameOptionsManager.cs
    
Offset 13, 14 lines modifiedOffset 13, 19 lines modified
13 »       {13 »       {
14 »       »       get14 »       »       get
15 »       »       {15 »       »       {
16 »       »       »       return·this.currentGameOptions·!=·null;16 »       »       »       return·this.currentGameOptions·!=·null;
17 »       »       }17 »       »       }
18 »       }18 »       }
19 19
 20 »       public·Type·GetGameOptions()
 21 »       {
 22 »       »       return·typeof(NormalGameOptionsV08);
 23 »       }
 24
20 »       public·IGameOptions·CurrentGameOptions25 »       public·IGameOptions·CurrentGameOptions
21 »       {26 »       {
22 »       »       get27 »       »       get
23 »       »       {28 »       »       {
24 »       »       »       if·(this.currentGameOptions·==·null)29 »       »       »       if·(this.currentGameOptions·==·null)
25 »       »       »       {30 »       »       »       {
26 »       »       »       »       this.logger.WriteError("CurrentGameOptions·was·null·on·get");31 »       »       »       »       this.logger.WriteError("CurrentGameOptions·was·null·on·get");
Offset 32, 26 lines modifiedOffset 37, 26 lines modified
32 »       »       {37 »       »       {
33 »       »       »       GameModes·gameMode·=·value.GameMode;38 »       »       »       GameModes·gameMode·=·value.GameMode;
34 »       »       »       this.SwitchGameMode(gameMode);39 »       »       »       this.SwitchGameMode(gameMode);
35 »       »       »       switch·(gameMode)40 »       »       »       switch·(gameMode)
36 »       »       »       {41 »       »       »       {
37 »       »       »       case·GameModes.Normal:42 »       »       »       case·GameModes.Normal:
38 »       »       »       case·GameModes.NormalFools:43 »       »       »       case·GameModes.NormalFools:
39 »       »       »       »       this.currentNormalGameOptions·=·value·as·NormalGameOptionsV07;44 »       »       »       »       this.currentNormalGameOptions·=·value·as·NormalGameOptionsV08;
40 »       »       »       »       if·(this.currentNormalGameOptions·==·null)45 »       »       »       »       if·(this.currentNormalGameOptions·==·null)
41 »       »       »       »       {46 »       »       »       »       {
42 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV07)));47 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV08)));
43 »       »       »       »       }48 »       »       »       »       }
44 »       »       »       »       break;49 »       »       »       »       break;
45 »       »       »       case·GameModes.HideNSeek:50 »       »       »       case·GameModes.HideNSeek:
46 »       »       »       case·GameModes.SeekFools:51 »       »       »       case·GameModes.SeekFools:
47 »       »       »       »       this.currentHideNSeekGameOptions·=·value·as·HideNSeekGameOptionsV07;52 »       »       »       »       this.currentHideNSeekGameOptions·=·value·as·HideNSeekGameOptionsV08;
48 »       »       »       »       if·(this.currentHideNSeekGameOptions·==·null)53 »       »       »       »       if·(this.currentHideNSeekGameOptions·==·null)
49 »       »       »       »       {54 »       »       »       »       {
50 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV07)));55 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·current·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV08)));
51 »       »       »       »       }56 »       »       »       »       }
52 »       »       »       »       break;57 »       »       »       »       break;
53 »       »       »       default:58 »       »       »       default:
54 »       »       »       »       this.logger.WriteError(string.Format("Cannot·cache·settings·for·game·mode·{0}",·gameMode));59 »       »       »       »       this.logger.WriteError(string.Format("Cannot·cache·settings·for·game·mode·{0}",·gameMode));
55 »       »       »       »       break;60 »       »       »       »       break;
56 »       »       »       }61 »       »       »       }
57 »       »       »       this.currentGameOptions·=·value;62 »       »       »       this.currentGameOptions·=·value;
Offset 68, 30 lines modifiedOffset 73, 30 lines modified
68 »       »       {73 »       »       {
69 »       »       »       GameModes·gameMode·=·value.GameMode;74 »       »       »       GameModes·gameMode·=·value.GameMode;
70 »       »       »       this.SwitchGameMode(gameMode);75 »       »       »       this.SwitchGameMode(gameMode);
71 »       »       »       switch·(gameMode)76 »       »       »       switch·(gameMode)
72 »       »       »       {77 »       »       »       {
73 »       »       »       case·GameModes.Normal:78 »       »       »       case·GameModes.Normal:
74 »       »       »       case·GameModes.NormalFools:79 »       »       »       case·GameModes.NormalFools:
75 »       »       »       »       this.normalGameHostOptions·=·value·as·NormalGameOptionsV07;80 »       »       »       »       this.normalGameHostOptions·=·value·as·NormalGameOptionsV08;
76 »       »       »       »       if·(this.normalGameHostOptions·==·null)81 »       »       »       »       if·(this.normalGameHostOptions·==·null)
77 »       »       »       »       {82 »       »       »       »       {
78 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV07)));83 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV08)));
79 »       »       »       »       }84 »       »       »       »       }
80 »       »       »       »       else85 »       »       »       »       else
81 »       »       »       »       {86 »       »       »       »       {
82 »       »       »       »       »       this.SaveNormalHostOptions();87 »       »       »       »       »       this.SaveNormalHostOptions();
83 »       »       »       »       }88 »       »       »       »       }
84 »       »       »       »       break;89 »       »       »       »       break;
85 »       »       »       case·GameModes.HideNSeek:90 »       »       »       case·GameModes.HideNSeek:
86 »       »       »       case·GameModes.SeekFools:91 »       »       »       case·GameModes.SeekFools:
87 »       »       »       »       this.hideNSeekGameHostOptions·=·value·as·HideNSeekGameOptionsV07;92 »       »       »       »       this.hideNSeekGameHostOptions·=·value·as·HideNSeekGameOptionsV08;
88 »       »       »       »       if·(this.hideNSeekGameHostOptions·==·null)93 »       »       »       »       if·(this.hideNSeekGameHostOptions·==·null)
89 »       »       »       »       {94 »       »       »       »       {
90 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV07)));95 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·host·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV08)));
91 »       »       »       »       }96 »       »       »       »       }
92 »       »       »       »       else97 »       »       »       »       else
93 »       »       »       »       {98 »       »       »       »       {
94 »       »       »       »       »       this.SaveHideNSeekHostOptions();99 »       »       »       »       »       this.SaveHideNSeekHostOptions();
95 »       »       »       »       }100 »       »       »       »       }
96 »       »       »       »       break;101 »       »       »       »       break;
97 »       »       »       default:102 »       »       »       default:
Offset 112, 30 lines modifiedOffset 117, 30 lines modified
112 »       »       {117 »       »       {
113 »       »       »       GameModes·gameMode·=·value.GameMode;118 »       »       »       GameModes·gameMode·=·value.GameMode;
114 »       »       »       this.SwitchGameMode(gameMode);119 »       »       »       this.SwitchGameMode(gameMode);
115 »       »       »       switch·(gameMode)120 »       »       »       switch·(gameMode)
116 »       »       »       {121 »       »       »       {
117 »       »       »       case·GameModes.Normal:122 »       »       »       case·GameModes.Normal:
118 »       »       »       case·GameModes.NormalFools:123 »       »       »       case·GameModes.NormalFools:
119 »       »       »       »       this.normalGameSearchOptions·=·value·as·NormalGameOptionsV07;124 »       »       »       »       this.normalGameSearchOptions·=·value·as·NormalGameOptionsV08;
120 »       »       »       »       if·(this.normalGameSearchOptions·==·null)125 »       »       »       »       if·(this.normalGameSearchOptions·==·null)
121 »       »       »       »       {126 »       »       »       »       {
122 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV07)));127 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(NormalGameOptionsV08)));
123 »       »       »       »       }128 »       »       »       »       }
124 »       »       »       »       else129 »       »       »       »       else
125 »       »       »       »       {130 »       »       »       »       {
126 »       »       »       »       »       this.SaveNormalSearchOptions();131 »       »       »       »       »       this.SaveNormalSearchOptions();
127 »       »       »       »       }132 »       »       »       »       }
128 »       »       »       »       break;133 »       »       »       »       break;
129 »       »       »       case·GameModes.HideNSeek:134 »       »       »       case·GameModes.HideNSeek:
130 »       »       »       case·GameModes.SeekFools:135 »       »       »       case·GameModes.SeekFools:
131 »       »       »       »       this.hideNSeekGameSearchOptions·=·value·as·HideNSeekGameOptionsV07;136 »       »       »       »       this.hideNSeekGameSearchOptions·=·value·as·HideNSeekGameOptionsV08;
132 »       »       »       »       if·(this.hideNSeekGameSearchOptions·==·null)137 »       »       »       »       if·(this.hideNSeekGameSearchOptions·==·null)
133 »       »       »       »       {138 »       »       »       »       {
134 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV07)));139 »       »       »       »       »       this.logger.WriteError(string.Format("Setting·search·options·game·mode·as·{0}·but·options·data·type·is·not·of·type·{1}",·gameMode,·typeof(HideNSeekGameOptionsV08)));
135 »       »       »       »       }140 »       »       »       »       }
136 »       »       »       »       else141 »       »       »       »       else
137 »       »       »       »       {142 »       »       »       »       {
138 »       »       »       »       »       this.SaveHideNSeekSearchOptions();143 »       »       »       »       »       this.SaveHideNSeekSearchOptions();
139 »       »       »       »       }144 »       »       »       »       }
140 »       »       »       »       break;145 »       »       »       »       break;
141 »       »       »       default:146 »       »       »       default:
Offset 151, 19 lines modifiedOffset 156, 25 lines modified
151 »       »       if·(GameOptionsManager.Instance·!=·null)156 »       »       if·(GameOptionsManager.Instance·!=·null)
152 »       »       {157 »       »       {
153 »       »       »       throw·new·Exception("CANNOT·HAVE·MORE·THAN·ONE·OPTIONS·MANAGER·INSTANCE!");158 »       »       »       throw·new·Exception("CANNOT·HAVE·MORE·THAN·ONE·OPTIONS·MANAGER·INSTANCE!");
154 »       »       }159 »       »       }
155 »       »       GameOptionsManager.Instance·=·this;160 »       »       GameOptionsManager.Instance·=·this;
156 »       »       this.gameOptionsFactory·=·new·GameOptionsFactory(logger);161 »       »       this.gameOptionsFactory·=·new·GameOptionsFactory(logger);
157 »       »       this.logger·=·logger;162 »       »       this.logger·=·logger;
158 »       »       this.optionsMigrators·=·new·Dictionary<int,·IGameOptionsMigrator>·{·163 »       »       this.optionsMigrators·=·new·Dictionary<int,·IGameOptionsMigrator>
159 »       »       {164 »       »       {
 165 »       »       »       {
160 »       »       »       6,166 »       »       »       »       6,
161 »       »       »       new·GameOptionsMigratorV06toV07(logger)167 »       »       »       »       new·GameOptionsMigratorV06toV07(logger)
 168 »       »       »       },
 169 »       »       »       {
 170 »       »       »       »       7,
 171 »       »       »       »       new·GameOptionsMigratorV07toV08(logger)
 172 »       »       »       }
162 »       »       }·};173 »       »       };
Max diff block lines reached; 10363/15951 bytes (64.97%) of diff not shown.
16.7 KB
Assembly-CSharp/GameOptionsMenu.cs
    
Offset 1, 221 lines modifiedOffset 1, 297 lines modified
1 using·System;1 using·System;
 2 using·System.Collections.Generic;
2 using·AmongUs.GameOptions;3 using·AmongUs.GameOptions;
3 using·UnityEngine;4 using·UnityEngine;
4 5
5 public·class·GameOptionsMenu·:·MonoBehaviour6 public·class·GameOptionsMenu·:·MonoBehaviour
6 {7 {
7 »       private·void·Start()8 »       private·void·Awake()
8 »       {9 »       {
9 »       »       this.Children·=·base.GetComponentsInChildren<OptionBehaviour>(); 
10 »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions; 
11 »       »       for·(int·i·=·0;·i·<·this.Children.Length;·i++)10 »       »       this.MaskBg.material.SetInt(PlayerMaterial.MaskLayer,·20);
 11 »       »       this.MaskArea.material.SetInt(PlayerMaterial.MaskLayer,·20);
 12 »       }
 13
 14 »       private·void·CreateSettings()
 15 »       {
 16 »       »       float·num·=·0.713f;
 17 »       »       foreach·(RulesCategory·rulesCategory·in·GameManager.Instance.GameSettingsList.AllCategories)
12 »       »       {18 »       »       {
13 »       »       »       OptionBehaviour·optionBehaviour·=·this.Children[i]; 
14 »       »       »       optionBehaviour.OnValueChanged·=·new·Action<OptionBehaviour>(this.ValueChanged); 
15 »       »       »       if·(AmongUsClient.Instance·&&·!AmongUsClient.Instance.AmHost)19 »       »       »       CategoryHeaderMasked·categoryHeaderMasked·=·Object.Instantiate<CategoryHeaderMasked>(this.categoryHeaderOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer);
 20 »       »       »       categoryHeaderMasked.SetHeader(rulesCategory.CategoryName,·20);
 21 »       »       »       categoryHeaderMasked.transform.localScale·=·Vector3.one·*·0.63f;
 22 »       »       »       categoryHeaderMasked.transform.localPosition·=·new·Vector3(-0.903f,·num,·-2f);
 23 »       »       »       num·-=·0.63f;
 24 »       »       »       foreach·(BaseGameSetting·baseGameSetting·in·rulesCategory.AllGameSettings)
16 »       »       »       {25 »       »       »       {
17 »       »       »       »       optionBehaviour.SetAsPlayer();26 »       »       »       »       switch·(baseGameSetting.Type)
 27 »       »       »       »       {
 28 »       »       »       »       case·OptionTypes.Checkbox:
 29 »       »       »       »       {
 30 »       »       »       »       »       OptionBehaviour·optionBehaviour·=·Object.Instantiate<ToggleOption>(this.checkboxOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer);
 31 »       »       »       »       »       optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f);
 32 »       »       »       »       »       optionBehaviour.SetClickMask(this.ButtonClickMask);
 33 »       »       »       »       »       optionBehaviour.SetUpFromData(baseGameSetting,·20);
 34 »       »       »       »       »       this.Children.Add(optionBehaviour);
 35 »       »       »       »       »       break;
 36 »       »       »       »       }
 37 »       »       »       »       case·OptionTypes.String:
 38 »       »       »       »       {
 39 »       »       »       »       »       OptionBehaviour·optionBehaviour·=·Object.Instantiate<StringOption>(this.stringOptionOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer);
 40 »       »       »       »       »       optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f);
 41 »       »       »       »       »       optionBehaviour.SetClickMask(this.ButtonClickMask);
 42 »       »       »       »       »       optionBehaviour.SetUpFromData(baseGameSetting,·20);
 43 »       »       »       »       »       this.Children.Add(optionBehaviour);
 44 »       »       »       »       »       break;
 45 »       »       »       »       }
 46 »       »       »       »       case·OptionTypes.Float:
 47 »       »       »       »       case·OptionTypes.Int:
 48 »       »       »       »       {
 49 »       »       »       »       »       OptionBehaviour·optionBehaviour·=·Object.Instantiate<NumberOption>(this.numberOptionOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer);
 50 »       »       »       »       »       optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f);
 51 »       »       »       »       »       optionBehaviour.SetClickMask(this.ButtonClickMask);
 52 »       »       »       »       »       optionBehaviour.SetUpFromData(baseGameSetting,·20);
 53 »       »       »       »       »       this.Children.Add(optionBehaviour);
 54 »       »       »       »       »       break;
 55 »       »       »       »       }
 56 »       »       »       »       case·OptionTypes.Player:
 57 »       »       »       »       {
 58 »       »       »       »       »       OptionBehaviour·optionBehaviour·=·Object.Instantiate<PlayerOption>(this.playerOptionOrigin,·Vector3.zero,·Quaternion.identity,·this.settingsContainer);
 59 »       »       »       »       »       optionBehaviour.transform.localPosition·=·new·Vector3(0.952f,·num,·-2f);
 60 »       »       »       »       »       optionBehaviour.SetClickMask(this.ButtonClickMask);
 61 »       »       »       »       »       optionBehaviour.SetUpFromData(baseGameSetting,·20);
 62 »       »       »       »       »       this.Children.Add(optionBehaviour);
 63 »       »       »       »       »       break;
 64 »       »       »       »       }
 65 »       »       »       »       }
 66 »       »       »       »       num·-=·0.45f;
18 »       »       »       }67 »       »       »       }
19 »       »       }68 »       »       }
 69 »       »       this.ControllerSelectable.AddRange(this.scrollBar.GetComponentsInChildren<UiElement>());
 70 »       »       this.scrollBar.SetYBoundsMax(-num·-·1.65f);
 71 »       }
 72
 73 »       private·void·Initialize()
 74 »       {
 75 »       »       if·(this.Children·==·null·||·this.Children.Count·==·0)
 76 »       »       {
 77 »       »       »       this.MapPicker.Initialize(20);
 78 »       »       »       BaseGameSetting·mapNameSetting·=·GameManager.Instance.GameSettingsList.MapNameSetting;
 79 »       »       »       this.MapPicker.SetUpFromData(mapNameSetting,·20);
 80 »       »       »       this.Children·=·new·List<OptionBehaviour>();
 81 »       »       »       this.Children.Add(this.MapPicker);
 82 »       »       »       this.CreateSettings();
 83 »       »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions;
 84 »       »       »       for·(int·i·=·0;·i·<·this.Children.Count;·i++)
 85 »       »       »       {
 86 »       »       »       »       OptionBehaviour·optionBehaviour·=·this.Children[i];
 87 »       »       »       »       optionBehaviour.OnValueChanged·=·new·Action<OptionBehaviour>(this.ValueChanged);
 88 »       »       »       »       if·(AmongUsClient.Instance·&&·!AmongUsClient.Instance.AmHost)
 89 »       »       »       »       {
 90 »       »       »       »       »       optionBehaviour.SetAsPlayer();
 91 »       »       »       »       }
 92 »       »       »       }
 93 »       »       »       this.InitializeControllerNavigation();
 94 »       »       }
20 »       }95 »       }
21 96
22 »       private·void·Update()97 »       private·void·Update()
23 »       {98 »       {
24 »       »       if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions)99 »       »       if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions)
25 »       »       {100 »       »       {
26 »       »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions;101 »       »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions;
27 »       »       »       this.RefreshChildren();102 »       »       »       this.RefreshChildren();
28 »       »       }103 »       »       }
29 »       }104 »       }
30 105
 106 »       private·void·OnEnable()
 107 »       {
 108 »       »       this.Initialize();
 109 »       }
 110
 111 »       private·void·OnDisable()
 112 »       {
 113 »       »       this.CloseMenu();
 114 »       }
 115
 116 »       public·void·OpenMenu()
 117 »       {
 118 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.MapPicker.MapButtons[0].Button,·this.ControllerSelectable,·false);
 119 »       }
 120
 121 »       public·void·CloseMenu()
 122 »       {
 123 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);
Max diff block lines reached; 11955/17064 bytes (70.06%) of diff not shown.
11.1 KB
Assembly-CSharp/GameSettingMenu.cs
    
Offset 1, 242 lines modifiedOffset 1, 197 lines modified
1 using·System;1 using·System;
 2 using·System.Collections;
2 using·System.Collections.Generic;3 using·System.Collections.Generic;
3 using·AmongUs.GameOptions; 
4 using·Rewired; 
5 using·TMPro;4 using·TMPro;
6 using·UnityEngine;5 using·UnityEngine;
7 6
8 public·class·GameSettingMenu·:·MonoBehaviour7 public·class·GameSettingMenu·:·MonoBehaviour
9 {8 {
10 »       public·void·Close()9 »       public·void·Close()
11 »       {10 »       {
12 »       »       GameSettingMenu.Instance·=·null;11 »       »       GameSettingMenu.Instance·=·null;
13 »       »       Object.Destroy(base.gameObject);12 »       »       Object.Destroy(base.gameObject);
14 »       }13 »       }
15 14
16 »       public·void·ToggleRoles() 
17 »       { 
18 »       »       bool·activeSelf·=·this.RegularGameSettings.activeSelf; 
19 »       »       this.RegularGameSettings.SetActive(!activeSelf); 
20 »       »       this.RolesSettings.gameObject.SetActive(activeSelf); 
21 »       »       this.GameSettingsHightlight.enabled·=·!activeSelf; 
22 »       »       this.RolesSettingsHightlight.enabled·=·activeSelf; 
23 »       } 
24  
25 »       private·void·Start()15 »       private·void·Start()
26 »       {16 »       {
27 »       »       if·(GameSettingMenu.Instance·&&·GameSettingMenu.Instance·!=·this)17 »       »       if·(GameSettingMenu.Instance·&&·GameSettingMenu.Instance·!=·this)
28 »       »       {18 »       »       {
29 »       »       »       Object.Destroy(base.gameObject);19 »       »       »       Object.Destroy(base.gameObject);
30 »       »       }20 »       »       }
31 »       »       else21 »       »       else
32 »       »       {22 »       »       {
33 »       »       »       GameSettingMenu.Instance·=·this;23 »       »       »       GameSettingMenu.Instance·=·this;
34 »       »       }24 »       »       }
 25 »       »       this.GamePresetsButton.OnClick.AddListener(delegate
35 »       »       DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(false); 
36 »       »       this.ShowSettingsByGameType(); 
37 »       } 
38  
39 »       private·void·ShowSettingsByGameType() 
40 »       { 
41 »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek) 
42 »       »       {26 »       »       {
43 »       »       »       this.InitializeHideAndSeekOptions(); 
44 »       »       »       this.HideNSeekSettings.SetActive(true);27 »       »       »       this.ChangeTab(0,·false);
 28 »       »       });
 29 »       »       this.GamePresetsButton.OnMouseOver.AddListener(delegate
 30 »       »       {
 31 »       »       »       this.ChangeTab(0,·true);
 32 »       »       });
 33 »       »       this.GameSettingsButton.OnClick.AddListener(delegate
 34 »       »       {
 35 »       »       »       this.ChangeTab(1,·false);
 36 »       »       });
 37 »       »       this.GameSettingsButton.OnMouseOver.AddListener(delegate
 38 »       »       {
 39 »       »       »       this.ChangeTab(1,·true);
 40 »       »       });
 41 »       »       this.RoleSettingsButton.OnClick.AddListener(delegate
 42 »       »       {
 43 »       »       »       this.ChangeTab(2,·false);
 44 »       »       });
 45 »       »       this.RoleSettingsButton.OnMouseOver.AddListener(delegate
 46 »       »       {
 47 »       »       »       this.ChangeTab(2,·true);
 48 »       »       });
 49 »       »       if·(GameManager.Instance.IsHideAndSeek())
 50 »       »       {
45 »       »       »       this.RolesSettings.gameObject.SetActive(false);51 »       »       »       this.RoleSettingsButton.gameObject.SetActive(false);
46 »       »       »       this.RegularGameSettings.SetActive(false); 
47 »       »       »       this.Tabs.SetActive(false); 
48 »       »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected[1],·this.ControllerSelectableHidenSeek,·false); 
49 »       »       »       return; 
50 »       »       }52 »       »       }
51 »       »       this.InitializeNormalOptions(); 
52 »       »       this.RolesSettings.gameObject.SetActive(false); 
53 »       »       this.RegularGameSettings.SetActive(true); 
54 »       »       this.HideNSeekSettings.SetActive(false); 
55 »       »       this.Tabs.SetActive(true); 
56 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected[0],·this.ControllerSelectable,·false); 
57 »       }53 »       }
58 54
59 »       private·void·Update()55 »       private·void·Update()
60 »       {56 »       {
61 »       »       if·(ShipStatus.Instance)57 »       »       if·(ShipStatus.Instance)
62 »       »       {58 »       »       {
63 »       »       »       this.Close();59 »       »       »       this.Close();
64 »       »       »       return;60 »       »       »       return;
65 »       »       }61 »       »       }
 62 »       »       if·(Controller.currentTouchType·!=·Controller.TouchType.Joystick)
66 »       »       Player·player·=·ReInput.players.GetPlayer(0); 
67 »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.Normal·&&·(player.GetButtonDown(35)·||·player.GetButtonDown(34))) 
68 »       »       {63 »       »       {
69 »       »       »       this.ToggleRoles();64 »       »       »       this.ToggleLeftSideDarkener(false);
 65 »       »       »       this.ToggleRightSideDarkener(false);
70 »       »       }66 »       »       }
71 »       }67 »       }
72 68
73 »       private·void·OnEnable()69 »       private·void·OnEnable()
74 »       {70 »       {
75 »       »       this.ShowSettingsByGameType();71 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected,·this.ControllerSelectable,·false);
 72 »       »       DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(false);
 73 »       »       if·(Controller.currentTouchType·!=·Controller.TouchType.Joystick)
 74 »       »       {
 75 »       »       »       this.ChangeTab(0,·Controller.currentTouchType·==·Controller.TouchType.Joystick);
 76 »       »       }
 77 »       »       base.StartCoroutine(this.CoSelectDefault());
76 »       }78 »       }
77 79
78 »       private·void·OnDisable()80 »       private·void·OnDisable()
79 »       {81 »       {
80 »       »       DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(true);82 »       »       DestroyableSingleton<HudManager>.Instance.menuNavigationPrompts.SetActive(true);
81 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);83 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);
82 »       }84 »       }
83 85
 86 »       private·IEnumerator·CoSelectDefault()
84 »       private·void·InitializeHideAndSeekOptions() 
85 »       { 
86 »       »       this.InitializeOptions(this.AllHideAndSeekItems,·this.HideAndSeekScroller); 
87 »       } 
88  
89 »       private·void·InitializeNormalOptions() 
90 »       {87 »       {
91 »       »       this.InitializeOptions(this.AllItems,·this.Scroller);88 »       »       yield·return·new·WaitForEndOfFrame();
 89 »       »       ControllerManager.Instance.SetCurrentSelected(this.DefaultButtonSelected);
 90 »       »       yield·break;
Max diff block lines reached; 7078/11321 bytes (62.52%) of diff not shown.
22.0 KB
Assembly-CSharp/GameStartManager.cs
    
Offset 1, 101 lines modifiedOffset 1, 237 lines modified
1 using·System;1 using·System;
2 using·System.Collections;2 using·System.Collections.Generic;
3 using·AmongUs.Data;3 using·AmongUs.Data;
 4 using·AmongUs.GameOptions;
4 using·InnerNet;5 using·InnerNet;
5 using·TMPro;6 using·TMPro;
6 using·UnityEngine;7 using·UnityEngine;
7 8
8 public·class·GameStartManager·:·DestroyableSingleton<GameStartManager>,·IDisconnectHandler9 public·class·GameStartManager·:·DestroyableSingleton<GameStartManager>,·IDisconnectHandler
9 {10 {
 11 »       public·bool·IsPersistent
 12 »       {
 13 »       »       get
 14 »       »       {
 15 »       »       »       return·false;
 16 »       »       }
 17 »       }
 18
10 »       public·void·Start()19 »       public·void·Start()
11 »       {20 »       {
12 »       »       if·(DestroyableSingleton<TutorialManager>.InstanceExists)21 »       »       if·(DestroyableSingleton<TutorialManager>.InstanceExists)
13 »       »       {22 »       »       {
14 »       »       »       Object.Destroy(base.gameObject);23 »       »       »       Object.Destroy(base.gameObject);
15 »       »       »       return;24 »       »       »       return;
16 »       »       }25 »       »       }
 26 »       »       this.LobbyInfoPane.gameObject.SetActive(true);
17 »       »       DataManager.Settings.Gameplay.OnStreamerModeChanged·+=·this.UpdateStreamerModeUI;27 »       »       DataManager.Settings.Gameplay.OnStreamerModeChanged·+=·this.UpdateStreamerModeUI;
18 »       »       this.UpdateStreamerModeUI();28 »       »       this.UpdateStreamerModeUI();
19 »       »       if·(GameCode.IntToGameName(AmongUsClient.Instance.GameId)·!=·null)29 »       »       if·(GameCode.IntToGameName(AmongUsClient.Instance.GameId)·==·null)
20 »       »       {30 »       »       {
 31 »       »       »       this.RoomCodeHeader.gameObject.SetActive(false);
21 »       »       »       this.GameRoomNameInfo.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoomCodeInfo,·Array.Empty<object>()); 
22 »       »       } 
23 »       »       else 
24 »       »       { 
25 »       »       »       this.StartButton.transform.localPosition·=·new·Vector3(0f,·-0.2f,·0f); 
26 »       »       »       this.PlayerCounter.transform.localPosition·=·new·Vector3(0f,·-0.8f,·0f); 
27 »       »       »       this.GameRoomButton.gameObject.SetActive(false);32 »       »       »       this.GameRoomButton.gameObject.SetActive(false);
 33 »       »       »       this.LocalLabel.gameObject.SetActive(true);
 34 »       »       »       this.HostPrivacyButtons.gameObject.SetActive(false);
 35 »       »       »       this.ClientPrivacyValue.gameObject.SetActive(true);
28 »       »       }36 »       »       }
29 »       »       AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);37 »       »       AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);
 38 »       »       this.DoHostSetup();
 39 »       »       if·(AmongUsClient.Instance.AmHost)
 40 »       »       {
 41 »       »       »       LobbyBehaviour.Instance·=·Object.Instantiate<LobbyBehaviour>(this.LobbyPrefab);
 42 »       »       »       AmongUsClient.Instance.Spawn(LobbyBehaviour.Instance,·-2,·SpawnFlags.None);
 43 »       »       }
 44 »       »       this.ShareOnDiscordButton.gameObject.SetActive(false);
 45 »       }
 46
 47 »       private·void·DoHostSetup()
 48 »       {
 49 »       »       string·text·=·GameCode.IntToGameName(AmongUsClient.Instance.GameId);
30 »       »       if·(!AmongUsClient.Instance.AmHost)50 »       »       if·(!AmongUsClient.Instance.AmHost)
31 »       »       {51 »       »       {
 52 »       »       »       this.HostPrivacyButtons.gameObject.SetActive(false);
 53 »       »       »       this.ClientPrivacyValue.gameObject.SetActive(true);
32 »       »       »       this.StartButton.gameObject.SetActive(false);54 »       »       »       this.StartButton.gameObject.SetActive(false);
 55 »       »       »       this.StartButtonClient.gameObject.SetActive(true);
 56 »       »       »       this.GameStartTextParent.SetActive(false);
 57 »       »       »       this.HostInfoPanelButtons.gameObject.SetActive(false);
 58 »       »       »       this.ClientInfoPanelButtons.gameObject.SetActive(true);
 59 »       »       »       return;
33 »       »       »       this.MakePublicButtonBehaviour.enabled·=·false; 
34 »       »       »       ActionMapGlyphDisplay·componentInChildren·=·this.MakePublicButton.GetComponentInChildren<ActionMapGlyphDisplay>(true); 
35 »       »       »       if·(componentInChildren) 
36 »       »       »       { 
37 »       »       »       »       componentInChildren.gameObject.SetActive(false); 
38 »       »       »       } 
39 »       »       }60 »       »       }
40 »       »       else61 »       »       if·(text·!=·null)
41 »       »       {62 »       »       {
42 »       »       »       LobbyBehaviour.Instance·=·Object.Instantiate<LobbyBehaviour>(this.LobbyPrefab); 
43 »       »       »       AmongUsClient.Instance.Spawn(LobbyBehaviour.Instance,·-2,·SpawnFlags.None);63 »       »       »       this.HostPrivacyButtons.gameObject.SetActive(true);
 64 »       »       »       this.ClientPrivacyValue.gameObject.SetActive(false);
44 »       »       }65 »       »       }
45 »       »       this.MakePublicButton.gameObject.SetActive(AmongUsClient.Instance.NetworkMode·==·NetworkModes.OnlineGame);66 »       »       this.HostInfoPanelButtons.gameObject.SetActive(true);
 67 »       »       this.ClientInfoPanelButtons.gameObject.SetActive(false);
 68 »       »       this.StartButton.gameObject.SetActive(true);
46 »       »       this.ShareOnDiscordButton.gameObject.SetActive(false);69 »       »       this.StartButtonClient.gameObject.SetActive(false);
47 »       }70 »       }
48 71
49 »       public·override·void·OnDestroy()72 »       public·override·void·OnDestroy()
50 »       {73 »       {
51 »       »       base.OnDestroy();74 »       »       base.OnDestroy();
52 »       »       DataManager.Settings.Gameplay.OnStreamerModeChanged·-=·this.UpdateStreamerModeUI;75 »       »       DataManager.Settings.Gameplay.OnStreamerModeChanged·-=·this.UpdateStreamerModeUI;
53 »       }76 »       }
54 77
 78 »       public·void·ClickEdit()
 79 »       {
 80 »       »       PlayerControl·localPlayer·=·PlayerControl.LocalPlayer;
 81 »       »       if·(AmongUsClient.Instance.AmHost)
 82 »       »       {
 83 »       »       »       localPlayer.NetTransform.Halt();
 84 »       »       »       GameObject·gameObject·=·Object.Instantiate<GameObject>(this.PlayerOptionsMenu);
 85 »       »       »       gameObject.transform.SetParent(Camera.main.transform,·false);
 86 »       »       »       gameObject.transform.localPosition·=·this.GameOptionsPosition;
 87 »       »       »       DestroyableSingleton<TransitionFade>.Instance.DoTransitionFade(null,·gameObject.gameObject,·null);
 88 »       »       »       this.RulesViewPanel.SetActive(false);
 89 »       »       »       this.SelectViewButton(false);
 90 »       »       »       this.LobbyInfoPane.DeactivatePane();
 91 »       »       }
 92 »       }
 93
55 »       private·void·UpdateStreamerModeUI()94 »       private·void·UpdateStreamerModeUI()
56 »       {95 »       {
57 »       »       string·text·=·GameCode.IntToGameName(AmongUsClient.Instance.GameId);96 »       »       string·text·=·GameCode.IntToGameName(AmongUsClient.Instance.GameId);
58 »       »       if·(text·==·null)97 »       »       if·(text·==·null)
59 »       »       {98 »       »       {
60 »       »       »       text·=·"";99 »       »       »       text·=·string.Empty;
61 »       »       }100 »       »       }
62 »       »       this.GameRoomNameCode.text·=·(DataManager.Settings.Gameplay.StreamerMode·?·"******"·:·text);101 »       »       this.GameRoomNameCode.text·=·((DataManager.Settings.Gameplay.StreamerMode·&&·text·!=·string.Empty)·?·"******"·:·text);
63 »       }102 »       }
64 103
65 »       public·void·MakePublic()104 »       public·void·MakePublic()
66 »       {105 »       {
67 »       »       if·(AmongUsClient.Instance.AmHost)106 »       »       if·(AmongUsClient.Instance.AmHost)
68 »       »       {107 »       »       {
69 »       »       »       AmongUsClient.Instance.ChangeGamePublic(!AmongUsClient.Instance.IsGamePublic);108 »       »       »       AmongUsClient.Instance.ChangeGamePublic(!AmongUsClient.Instance.IsGamePublic);
70 »       »       »       this.MakePublicButton.sprite·=·(AmongUsClient.Instance.IsGamePublic·?·this.PublicGameImage·:·this.PrivateGameImage);109 »       »       »       this.HostPrivateButton.gameObject.SetActive(!AmongUsClient.Instance.IsGamePublic);
 110 »       »       »       this.HostPublicButton.gameObject.SetActive(AmongUsClient.Instance.IsGamePublic);
 111 »       »       »       if·(ActiveInputManager.currentControlType·==·ActiveInputManager.InputType.Joystick)
 112 »       »       »       {
 113 »       »       »       »       if·(AmongUsClient.Instance.IsGamePublic)
 114 »       »       »       »       {
Max diff block lines reached; 17081/22484 bytes (75.97%) of diff not shown.
1.47 KB
Assembly-CSharp/HandZiplinePoolable.cs
    
Offset 21, 18 lines modifiedOffset 21, 19 lines modified
21 »       }21 »       }
22 22
23 »       public·void·StartDownOutroAnimation()23 »       public·void·StartDownOutroAnimation()
24 »       {24 »       {
25 »       »       base.StartCoroutine(this.CoDownOutroAnimation());25 »       »       base.StartCoroutine(this.CoDownOutroAnimation());
26 »       }26 »       }
27 27
28 »       public·void·SetPlayerColor(GameData.PlayerOutfit·outfit,·PlayerMaterial.MaskType·maskType)28 »       public·void·SetPlayerColor(NetworkedPlayerInfo.PlayerOutfit·outfit,·PlayerMaterial.MaskType·maskType,·float·alpha)
29 »       {29 »       {
30 »       »       this.handRenderer.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType);30 »       »       this.handRenderer.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType);
31 »       »       PlayerMaterial.SetColors(outfit.ColorId,·this.handRenderer);31 »       »       PlayerMaterial.SetColors(outfit.ColorId,·this.handRenderer);
 32 »       »       this.handRenderer.color·=·this.handRenderer.color.SetAlpha(alpha);
32 »       }33 »       }
33 34
34 »       private·IEnumerator·CoDownAnimation()35 »       private·IEnumerator·CoDownAnimation()
35 »       {36 »       {
36 »       »       this.spriteAnim.Play(this.DownIntroAnim,·1f);37 »       »       this.spriteAnim.Play(this.DownIntroAnim,·1f);
37 »       »       yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.DownIntroAnim,·true,·-1);38 »       »       yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.DownIntroAnim,·true,·-1);
38 »       »       this.spriteAnim.Play(this.DownLoopAnim,·1f);39 »       »       this.spriteAnim.Play(this.DownLoopAnim,·1f);
Offset 59, 14 lines modifiedOffset 60, 23 lines modified
59 »       {60 »       {
60 »       »       this.spriteAnim.Play(this.UpOutroAnim,·1f);61 »       »       this.spriteAnim.Play(this.UpOutroAnim,·1f);
61 »       »       yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.UpOutroAnim,·true,·-1);62 »       »       yield·return·new·WaitForAnimationFinish(this.spriteAnim,·this.UpOutroAnim,·true,·-1);
62 »       »       base.gameObject.SetActive(false);63 »       »       base.gameObject.SetActive(false);
63 »       »       yield·break;64 »       »       yield·break;
64 »       }65 »       }
65 66
 67 »       public·void·Hide()
 68 »       {
 69 »       »       SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>();
 70 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)
 71 »       »       {
 72 »       »       »       componentsInChildren[i].color·=·Color.clear;
 73 »       »       }
 74 »       }
 75
66 »       [SerializeField]76 »       [SerializeField]
67 »       private·SpriteRenderer·handRenderer;77 »       private·SpriteRenderer·handRenderer;
68 78
69 »       [SerializeField]79 »       [SerializeField]
70 »       private·SpriteAnim·spriteAnim;80 »       private·SpriteAnim·spriteAnim;
71 81
72 »       [SerializeField]82 »       [SerializeField]
909 B
Assembly-CSharp/HatManager.cs
    
Offset 239, 15 lines modifiedOffset 239, 15 lines modified
239 »       »       }239 »       »       }
240 »       »       return·true;240 »       »       return·true;
241 »       }241 »       }
242 242
243 »       private·T[]·GetSorted<T>(List<T>·all)·where·T·:·CosmeticData243 »       private·T[]·GetSorted<T>(List<T>·all)·where·T·:·CosmeticData
244 »       {244 »       {
245 »       »       CosmeticGroups·groups·=·DestroyableSingleton<ReferenceDataManager>.Instance.Refdata.Groups;245 »       »       CosmeticGroups·groups·=·DestroyableSingleton<ReferenceDataManager>.Instance.Refdata.Groups;
246 »       »       T[]·array·=·Enumerable.ToArray<T>(Enumerable.ThenBy<T,·string>(Enumerable.ThenByDescending<T,·DateTime>(Enumerable.OrderBy<T,·int>(all,·(T·x)·=>·x.displayOrder),·(T·x)·=>·groups.GetReleaseGroupDate(x)),·(T·x)·=>·x.ProductId));246 »       »       T[]·array·=·Enumerable.ToArray<T>(Enumerable.ThenBy<T,·int>(Enumerable.ThenByDescending<T,·DateTime>(Enumerable.OrderBy<T,·int>(all,·(T·x)·=>·x.displayOrder),·(T·x)·=>·groups.GetReleaseGroupDate(x)),·(T·x)·=>·groups.GetReleaseGroupIndex(x)));
247 »       »       List<T>·list·=·new·List<T>();247 »       »       List<T>·list·=·new·List<T>();
248 »       »       foreach·(T·t·in·array)248 »       »       foreach·(T·t·in·array)
249 »       »       {249 »       »       {
250 »       »       »       if·(!list.Contains(t))250 »       »       »       if·(!list.Contains(t))
251 »       »       »       {251 »       »       »       {
252 »       »       »       »       if·(this.CheckValidCosmetic(t.ProdId))252 »       »       »       »       if·(this.CheckValidCosmetic(t.ProdId))
253 »       »       »       »       {253 »       »       »       »       {
2.35 KB
Assembly-CSharp/HatParent.cs
    
Offset 94, 18 lines modifiedOffset 94, 24 lines modified
94 »       »       if·(!this.Hat)94 »       »       if·(!this.Hat)
95 »       »       {95 »       »       {
96 »       »       »       return;96 »       »       »       return;
97 »       »       }97 »       »       }
98 »       »       this.SetHat(colorId);98 »       »       this.SetHat(colorId);
99 »       }99 »       }
100 100
 101 »       public·void·SetShouldFaceLeft(bool·leftFacingVictim)
 102 »       {
 103 »       »       this.shouldFaceLeft·=·leftFacingVictim;
 104 »       }
 105
101 »       public·void·SetFloorAnim()106 »       public·void·SetFloorAnim()
102 »       {107 »       {
103 »       »       this.BackLayer.enabled·=·false;108 »       »       this.BackLayer.enabled·=·false;
104 »       »       this.FrontLayer.enabled·=·true;109 »       »       this.FrontLayer.enabled·=·true;
 110 »       »       this.FrontLayer.flipX·=·false;
105 »       »       this.FrontLayer.sprite·=·this.viewAsset.GetAsset().FloorImage;111 »       »       this.FrontLayer.sprite·=·this.viewAsset.GetAsset().FloorImage;
106 »       }112 »       }
107 113
108 »       public·void·SetClimbAnim()114 »       public·void·SetClimbAnim()
109 »       {115 »       {
110 »       »       if·(!this.options.ShowForClimb)116 »       »       if·(!this.options.ShowForClimb)
111 »       »       {117 »       »       {
Offset 277, 24 lines modifiedOffset 283, 24 lines modified
277 »       »       »       HatViewData·hatViewData·=·((addressableAsset·!=·null)·?·addressableAsset.GetAsset()·:·null);283 »       »       »       HatViewData·hatViewData·=·((addressableAsset·!=·null)·?·addressableAsset.GetAsset()·:·null);
278 »       »       »       if·(this.Hat·&&·hatViewData·!=·null)284 »       »       »       if·(this.Hat·&&·hatViewData·!=·null)
279 »       »       »       {285 »       »       »       {
280 »       »       »       »       if·(this.FrontLayer.sprite·!=·hatViewData.ClimbImage·&&·this.FrontLayer.sprite·!=·hatViewData.FloorImage)286 »       »       »       »       if·(this.FrontLayer.sprite·!=·hatViewData.ClimbImage·&&·this.FrontLayer.sprite·!=·hatViewData.FloorImage)
281 »       »       »       »       {287 »       »       »       »       {
282 »       »       »       »       »       if·((this.Hat.InFront·||·hatViewData.BackImage)·&&·hatViewData.LeftMainImage)288 »       »       »       »       »       if·((this.Hat.InFront·||·hatViewData.BackImage)·&&·hatViewData.LeftMainImage)
283 »       »       »       »       »       {289 »       »       »       »       »       {
284 »       »       »       »       »       »       this.FrontLayer.sprite·=·(this.Parent.flipX·?·hatViewData.LeftMainImage·:·hatViewData.MainImage);290 »       »       »       »       »       »       this.FrontLayer.sprite·=·((this.Parent.flipX·||·this.shouldFaceLeft)·?·hatViewData.LeftMainImage·:·hatViewData.MainImage);
285 »       »       »       »       »       }291 »       »       »       »       »       }
286 »       »       »       »       »       if·(hatViewData.BackImage·&&·hatViewData.LeftBackImage)292 »       »       »       »       »       if·(hatViewData.BackImage·&&·hatViewData.LeftBackImage)
287 »       »       »       »       »       {293 »       »       »       »       »       {
288 »       »       »       »       »       »       this.BackLayer.sprite·=·(this.Parent.flipX·?·hatViewData.LeftBackImage·:·hatViewData.BackImage);294 »       »       »       »       »       »       this.BackLayer.sprite·=·((this.Parent.flipX·||·this.shouldFaceLeft)·?·hatViewData.LeftBackImage·:·hatViewData.BackImage);
289 »       »       »       »       »       »       return;295 »       »       »       »       »       »       return;
290 »       »       »       »       »       }296 »       »       »       »       »       }
291 »       »       »       »       »       if·(!hatViewData.BackImage·&&·!this.Hat.InFront·&&·hatViewData.LeftMainImage)297 »       »       »       »       »       if·(!hatViewData.BackImage·&&·!this.Hat.InFront·&&·hatViewData.LeftMainImage)
292 »       »       »       »       »       {298 »       »       »       »       »       {
293 »       »       »       »       »       »       this.BackLayer.sprite·=·(this.Parent.flipX·?·hatViewData.LeftMainImage·:·hatViewData.MainImage);299 »       »       »       »       »       »       this.BackLayer.sprite·=·((this.Parent.flipX·||·this.shouldFaceLeft)·?·hatViewData.LeftMainImage·:·hatViewData.MainImage);
294 »       »       »       »       »       »       return;300 »       »       »       »       »       »       return;
295 »       »       »       »       »       }301 »       »       »       »       »       }
296 »       »       »       »       }302 »       »       »       »       }
297 »       »       »       »       else·if·(this.FrontLayer.sprite·==·hatViewData.ClimbImage·||·this.FrontLayer.sprite·==·hatViewData.LeftClimbImage)303 »       »       »       »       else·if·(this.FrontLayer.sprite·==·hatViewData.ClimbImage·||·this.FrontLayer.sprite·==·hatViewData.LeftClimbImage)
298 »       »       »       »       {304 »       »       »       »       {
299 »       »       »       »       »       SpriteAnimNodeSync·spriteAnimNodeSync·=·this.SpriteSyncNode·??·base.GetComponent<SpriteAnimNodeSync>();305 »       »       »       »       »       SpriteAnimNodeSync·spriteAnimNodeSync·=·this.SpriteSyncNode·??·base.GetComponent<SpriteAnimNodeSync>();
300 »       »       »       »       »       if·(spriteAnimNodeSync)306 »       »       »       »       »       if·(spriteAnimNodeSync)
Offset 315, 8 lines modifiedOffset 321, 10 lines modified
315 »       public·SpriteAnimNodeSync·SpriteSyncNode;321 »       public·SpriteAnimNodeSync·SpriteSyncNode;
316 322
317 »       private·AddressableAsset<HatViewData>·viewAsset;323 »       private·AddressableAsset<HatViewData>·viewAsset;
318 324
319 »       private·PlayerMaterial.Properties·matProperties;325 »       private·PlayerMaterial.Properties·matProperties;
320 326
321 »       private·HatOptions·options;327 »       private·HatOptions·options;
 328
 329 »       private·bool·shouldFaceLeft;
322 }330 }
613 B
Assembly-CSharp/HauntMenuMinigame.cs
    
Offset 150, 15 lines modifiedOffset 150, 15 lines modified
150 »       »       »       this.FilterText.text·=·"";150 »       »       »       this.FilterText.text·=·"";
151 »       »       »       this.HauntingText.enabled·=·false;151 »       »       »       this.HauntingText.enabled·=·false;
152 »       »       »       return;152 »       »       »       return;
153 »       »       }153 »       »       }
154 »       »       this.HauntTarget·=·target;154 »       »       this.HauntTarget·=·target;
155 »       »       this.HauntingText.enabled·=·true;155 »       »       this.HauntingText.enabled·=·true;
156 »       »       TMP_Text·nameText·=·this.NameText;156 »       »       TMP_Text·nameText·=·this.NameText;
157 »       »       GameData.PlayerInfo·data·=·target.Data;157 »       »       NetworkedPlayerInfo·data·=·target.Data;
158 »       »       nameText.text·=·((data·!=·null)·?·data.GetPlayerName(PlayerOutfitType.Default)·:·null);158 »       »       nameText.text·=·((data·!=·null)·?·data.GetPlayerName(PlayerOutfitType.Default)·:·null);
159 »       »       this.SetFilterText();159 »       »       this.SetFilterText();
160 »       }160 »       }
161 161
162 »       public·override·void·Close()162 »       public·override·void·Close()
163 »       {163 »       {
164 »       »       DestroyableSingleton<HudManager>.Instance.ToggleMapButton(true);164 »       »       DestroyableSingleton<HudManager>.Instance.ToggleMapButton(true);
1.39 KB
Assembly-CSharp/HideAndSeekDeathPopupNameplate.cs
    
Offset 5, 15 lines modifiedOffset 5, 15 lines modified
5 public·class·HideAndSeekDeathPopupNameplate·:·MonoBehaviour5 public·class·HideAndSeekDeathPopupNameplate·:·MonoBehaviour
6 {6 {
7 »       public·void·SetPlayer(PlayerControl·player)7 »       public·void·SetPlayer(PlayerControl·player)
8 »       {8 »       {
9 »       »       this.SetPlayer(player.Data);9 »       »       this.SetPlayer(player.Data);
10 »       }10 »       }
11 11
12 »       public·void·SetPlayer(GameData.PlayerInfo·playerInfo)12 »       public·void·SetPlayer(NetworkedPlayerInfo·playerInfo)
13 »       {13 »       {
14 »       »       this.SetMaskLayer((int)playerInfo.PlayerId);14 »       »       this.SetMaskLayer((int)playerInfo.PlayerId);
15 »       »       this.background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image;15 »       »       this.background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image;
16 »       »       this.playerIcon.UpdateFromPlayerOutfit(playerInfo.Outfits[PlayerOutfitType.Default],·PlayerMaterial.MaskType.ComplexUI,·false,·false,·null,·false);16 »       »       this.playerIcon.UpdateFromPlayerOutfit(playerInfo.Outfits[PlayerOutfitType.Default],·PlayerMaterial.MaskType.ComplexUI,·false,·false,·null,·false);
17 »       »       this.playerIcon.ToggleName(false);17 »       »       this.playerIcon.ToggleName(false);
18 »       »       this.nameText.text·=·playerInfo.PlayerName;18 »       »       this.nameText.text·=·playerInfo.PlayerName;
19 »       »       this.levelText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel);19 »       »       this.levelText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel);
Offset 26, 21 lines modifiedOffset 26, 21 lines modified
26 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)26 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)
27 »       »       {27 »       »       {
28 »       »       »       componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·num);28 »       »       »       componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·num);
29 »       »       }29 »       »       }
30 »       »       this.playerIcon.SetMaskLayer(num);30 »       »       this.playerIcon.SetMaskLayer(num);
31 »       }31 »       }
32 32
33 »       [SerializeField] 
34 »       [Header("Nameplate")]33 »       [Header("Nameplate")]
 34 »       [SerializeField]
35 »       private·PoolablePlayer·playerIcon;35 »       private·PoolablePlayer·playerIcon;
36 36
37 »       [SerializeField]37 »       [SerializeField]
38 »       private·SpriteRenderer·background;38 »       private·SpriteRenderer·background;
39 39
40 »       [SerializeField] 
41 »       [Header("Text")]40 »       [Header("Text")]
 41 »       [SerializeField]
42 »       private·TextMeshPro·nameText;42 »       private·TextMeshPro·nameText;
43 43
44 »       [SerializeField]44 »       [SerializeField]
45 »       private·TextMeshPro·levelText;45 »       private·TextMeshPro·levelText;
46 }46 }
1.75 KB
Assembly-CSharp/HideAndSeekManager.cs
    
Offset 170, 29 lines modifiedOffset 170, 29 lines modified
170 »       »       »       mapOptions.ShowLivePlayerPosition·=·false;170 »       »       »       mapOptions.ShowLivePlayerPosition·=·false;
171 »       »       }171 »       »       }
172 »       »       return·mapOptions;172 »       »       return·mapOptions;
173 »       }173 »       }
174 174
175 »       private·void·CheckUpdateSurvivedStat()175 »       private·void·CheckUpdateSurvivedStat()
176 »       {176 »       {
177 »       »       if·(!PlayerControl.LocalPlayer.Data.IsDead·&&·!PlayerControl.LocalPlayer.Data.Role.IsImpostor)177 »       »       if·(!EndGameResult.CachedLocalPlayer.IsDead·&&·!EndGameResult.CachedLocalPlayer.IsImpostor)
178 »       »       {178 »       »       {
179 »       »       »       StatsManager.Instance.IncrementStat(StringNames.StatsHidenSeekGamesCrewmateSurvived);179 »       »       »       StatsManager.Instance.IncrementStat(StringNames.StatsHidenSeekGamesCrewmateSurvived);
180 »       »       }180 »       »       }
181 »       }181 »       }
182 182
183 »       private·void·CheckUpdateGameTimeStats()183 »       private·void·CheckUpdateGameTimeStats()
184 »       {184 »       {
185 »       »       float·roundTimeElapsed·=·this.LogicFlowHnS.GetRoundTimeElapsed();185 »       »       float·roundTimeElapsed·=·this.LogicFlowHnS.GetRoundTimeElapsed();
186 »       »       if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor·&&·this.DidImpostorsWin(TempData.EndReason))186 »       »       if·(EndGameResult.CachedLocalPlayer.IsImpostor·&&·this.DidImpostorsWin(EndGameResult.CachedGameOverReason))
187 »       »       {187 »       »       {
188 »       »       »       StatsManager.Instance.UpdateHideAndSeekImpostorWinTimer(roundTimeElapsed);188 »       »       »       StatsManager.Instance.UpdateHideAndSeekImpostorWinTimer(roundTimeElapsed);
189 »       »       »       return;189 »       »       »       return;
190 »       »       }190 »       »       }
191 »       »       if·(!PlayerControl.LocalPlayer.Data.Role.IsImpostor·&&·this.DidHumansWin(TempData.EndReason))191 »       »       if·(!EndGameResult.CachedLocalPlayer.IsImpostor·&&·this.DidHumansWin(EndGameResult.CachedGameOverReason))
192 »       »       {192 »       »       {
193 »       »       »       StatsManager.Instance.UpdateHideAndSeekCrewmateWinTimer(roundTimeElapsed);193 »       »       »       StatsManager.Instance.UpdateHideAndSeekCrewmateWinTimer(roundTimeElapsed);
194 »       »       }194 »       »       }
195 »       }195 »       }
196 196
197 »       public·override·bool·CanReportBodies()197 »       public·override·bool·CanReportBodies()
198 »       {198 »       {
Offset 254, 14 lines modifiedOffset 254, 14 lines modified
254 »       private·Sprite·BrokenEmergencyButton;254 »       private·Sprite·BrokenEmergencyButton;
255 255
256 »       [SerializeField]256 »       [SerializeField]
257 »       private·DeadBody·horseBody;257 »       private·DeadBody·horseBody;
258 258
259 »       private·TextMeshPro·someoneJustDiedText;259 »       private·TextMeshPro·someoneJustDiedText;
260 260
261 »       private·GameData.PlayerOutfit·horseWranglerOutfit·=·new·GameData.PlayerOutfit261 »       private·NetworkedPlayerInfo.PlayerOutfit·horseWranglerOutfit·=·new·NetworkedPlayerInfo.PlayerOutfit
262 »       {262 »       {
263 »       »       HatId·=·"hat_Starless",263 »       »       HatId·=·"hat_Starless",
264 »       »       SkinId·=·"skin_MilitaryDesert",264 »       »       SkinId·=·"skin_MilitaryDesert",
265 »       »       VisorId·=·"visor_WinstonStache"265 »       »       VisorId·=·"visor_WinstonStache"
266 »       };266 »       };
267 }267 }
2.26 KB
Assembly-CSharp/HoistSuppliesMinigame.cs
Ordering differences only
    
Offset 133, 32 lines modifiedOffset 133, 32 lines modified
133 »       private·Collider2D·draggable;133 »       private·Collider2D·draggable;
134 134
135 »       [Header("Input")]135 »       [Header("Input")]
136 »       [SerializeField]136 »       [SerializeField]
137 »       [Tooltip("The·difficulty·of·the·hoist·minigame,·increasing·as·the·target·gets·closer·to·completion.")]137 »       [Tooltip("The·difficulty·of·the·hoist·minigame,·increasing·as·the·target·gets·closer·to·completion.")]
138 »       private·AnimationCurve·liftMultiplierCurve;138 »       private·AnimationCurve·liftMultiplierCurve;
139 139
140 »       [SerializeField] 
141 »       [Range(0.01f,·4f)] 
142 »       [Tooltip("The·forced·delay·(in·seconds)·between·each·hoist·controller·button·press.·Players·cannot·press·the·hoist·button·faster·than·this.")]140 »       [Tooltip("The·forced·delay·(in·seconds)·between·each·hoist·controller·button·press.·Players·cannot·press·the·hoist·button·faster·than·this.")]
 141 »       [Range(0.01f,·4f)]
 142 »       [SerializeField]
143 »       private·float·controllerButtonDelay·=·0.2f;143 »       private·float·controllerButtonDelay·=·0.2f;
144 144
145 »       [Range(0.01f,·2f)]145 »       [Range(0.01f,·2f)]
146 »       [Tooltip("The·amount·added·every·time·a·controller·button·is·pressed·(Multiplied·by·the·liftMultiplierCurve)")] 
147 »       [SerializeField]146 »       [SerializeField]
 147 »       [Tooltip("The·amount·added·every·time·a·controller·button·is·pressed·(Multiplied·by·the·liftMultiplierCurve)")]
148 »       private·float·controllerRaiseAmount·=·0.4f;148 »       private·float·controllerRaiseAmount·=·0.4f;
149 149
150 »       [Tooltip("The·amount·of·offset·to·add·to·the·pull-rope·every·time·the·controller·pull·button·is·pressed")] 
151 »       [Range(0.01f,·2f)]150 »       [Range(0.01f,·2f)]
 151 »       [Tooltip("The·amount·of·offset·to·add·to·the·pull-rope·every·time·the·controller·pull·button·is·pressed")]
152 »       [SerializeField]152 »       [SerializeField]
153 »       private·float·controllerPullAmount·=·0.4f;153 »       private·float·controllerPullAmount·=·0.4f;
154 154
 155 »       [Tooltip("The·Speed·at·which·the·hoisted·sprite·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")]
155 »       [Header("Animation·Speeds")]156 »       [Header("Animation·Speeds")]
156 »       [SerializeField]157 »       [SerializeField]
157 »       [Tooltip("The·Speed·at·which·the·hoisted·sprite·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")] 
158 »       private·float·raiseAnimSpeed·=·5f;158 »       private·float·raiseAnimSpeed·=·5f;
159 159
160 »       [SerializeField]160 »       [SerializeField]
161 »       [Tooltip("The·Speed·at·which·the·pull-rope·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")]161 »       [Tooltip("The·Speed·at·which·the·pull-rope·animates·to·it's·intended·offset·each·time·the·controller·pull·button·is·pressed.·(Recommended·between·the·3-15·range)")]
162 »       private·float·pullAnimSpeed·=·5f;162 »       private·float·pullAnimSpeed·=·5f;
163 163
164 »       [SerializeField]164 »       [SerializeField]
Offset 193, 16 lines modifiedOffset 193, 16 lines modified
193 193
194 »       [SerializeField]194 »       [SerializeField]
195 »       private·Vector3·draggableRopeBottomPos;195 »       private·Vector3·draggableRopeBottomPos;
196 196
197 »       [SerializeField]197 »       [SerializeField]
198 »       private·Transform·ropeTexture;198 »       private·Transform·ropeTexture;
199 199
200 »       [Header("Lights")] 
201 »       [SerializeField]200 »       [SerializeField]
 201 »       [Header("Lights")]
202 »       private·GameObject·redCircle;202 »       private·GameObject·redCircle;
203 203
204 »       [SerializeField]204 »       [SerializeField]
205 »       private·GameObject·greenCircle;205 »       private·GameObject·greenCircle;
206 206
207 »       [SerializeField]207 »       [SerializeField]
208 »       [Header("Controller·Hint")]208 »       [Header("Controller·Hint")]
681 B
Assembly-CSharp/HorseWrangleOverlay.cs
    
Offset 2, 15 lines modifiedOffset 2, 15 lines modified
2 using·System.Collections;2 using·System.Collections;
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·class·HorseWrangleOverlay·:·OverlayKillAnimation5 public·class·HorseWrangleOverlay·:·OverlayKillAnimation
6 {6 {
7 »       public·override·IEnumerator·CoShow(KillOverlay·parent)7 »       public·override·IEnumerator·CoShow(KillOverlay·parent)
8 »       {8 »       {
9 »       »       this.victimParts.SetHatAndVisorOnFloor();9 »       »       this.victimParts.SetHatOnFloor();
10 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorForeground);10 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorForeground);
11 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorHand);11 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.impostorHand);
12 »       »       this.victimSprites.ForEach(delegate(SpriteRenderer·b)12 »       »       this.victimSprites.ForEach(delegate(SpriteRenderer·b)
13 »       »       {13 »       »       {
14 »       »       »       PlayerMaterial.SetColors(this.victimParts.ColorId,·b);14 »       »       »       PlayerMaterial.SetColors(this.victimParts.ColorId,·b);
15 »       »       });15 »       »       });
16 »       »       yield·return·base.CoShow(parent);16 »       »       yield·return·base.CoShow(parent);
2.06 KB
Assembly-CSharp/HowToPlayScene.cs
    
Offset 9, 18 lines modifiedOffset 9, 14 lines modified
9 »       public·void·Start()9 »       public·void·Start()
10 »       {10 »       {
11 »       »       this.category·=·HowToPlayScene.HowToPlayCategory.None;11 »       »       this.category·=·HowToPlayScene.HowToPlayCategory.None;
12 »       »       this.arrows.SetActive(false);12 »       »       this.arrows.SetActive(false);
13 »       »       this.startPage.SetActive(true);13 »       »       this.startPage.SetActive(true);
14 »       »       ControllerManager.Instance.NewScene(base.name,·this.closeButton,·this.defaultButtonSelected,·this.controllerSelectables,·false);14 »       »       ControllerManager.Instance.NewScene(base.name,·this.closeButton,·this.defaultButtonSelected,·this.controllerSelectables,·false);
15 »       »       this.SetupDots(0);15 »       »       this.SetupDots(0);
16 »       »       if·(!DataManager.Player.Onboarding.ViewedHideAndSeekHowToPlay) 
17 »       »       { 
18 »       »       »       this.StartHideAndSeek(); 
19 »       »       } 
20 »       }16 »       }
21 17
22 »       public·void·StartClassic()18 »       public·void·StartClassic()
23 »       {19 »       {
24 »       »       this.sceneIndex·=·0;20 »       »       this.sceneIndex·=·0;
25 »       »       this.category·=·HowToPlayScene.HowToPlayCategory.GameMode_Classic;21 »       »       this.category·=·HowToPlayScene.HowToPlayCategory.GameMode_Classic;
26 »       »       this.startPage.SetActive(false);22 »       »       this.startPage.SetActive(false);
Offset 171, 15 lines modifiedOffset 167, 15 lines modified
171 »       »       this.closeButton.gameObject.SetActive(this.CanClose());167 »       »       this.closeButton.gameObject.SetActive(this.CanClose());
172 »       »       this.SetActiveDot(this.sceneIndex);168 »       »       this.SetActiveDot(this.sceneIndex);
173 »       »       this.leftButton.gameObject.SetActive(this.sceneIndex·>·0);169 »       »       this.leftButton.gameObject.SetActive(this.sceneIndex·>·0);
174 »       }170 »       }
175 171
176 »       private·bool·CanClose()172 »       private·bool·CanClose()
177 »       {173 »       {
178 »       »       return·this.category·!=·HowToPlayScene.HowToPlayCategory.GameMode_HideAndSeek·||·DataManager.Player.Onboarding.ViewedHideAndSeekHowToPlay;174 »       »       return·true;
179 »       }175 »       }
180 176
181 »       private·void·SetupDots(int·count)177 »       private·void·SetupDots(int·count)
182 »       {178 »       {
183 »       »       if·(this.dots·!=·null)179 »       »       if·(this.dots·!=·null)
184 »       »       {180 »       »       {
185 »       »       »       Transform[]·array·=·this.dots;181 »       »       »       Transform[]·array·=·this.dots;
Offset 216, 41 lines modifiedOffset 212, 41 lines modified
216 »       »       »       return;212 »       »       »       return;
217 »       »       }213 »       »       }
218 »       »       this.dots[index].localScale·=·new·Vector3(1.5f,·1.5f,·1.5f);214 »       »       this.dots[index].localScale·=·new·Vector3(1.5f,·1.5f,·1.5f);
219 »       }215 »       }
220 216
221 »       public·static·string·SceneOnClose;217 »       public·static·string·SceneOnClose;
222 218
223 »       [Header("UI")] 
224 »       [SerializeField]219 »       [SerializeField]
 220 »       [Header("UI")]
225 »       private·GameObject·startPage;221 »       private·GameObject·startPage;
226 222
227 »       [SerializeField] 
228 »       [Space(10f)]223 »       [Space(10f)]
 224 »       [SerializeField]
229 »       private·GameObject·arrows;225 »       private·GameObject·arrows;
230 226
231 »       [SerializeField]227 »       [SerializeField]
232 »       private·SpriteRenderer·leftButton;228 »       private·SpriteRenderer·leftButton;
233 229
234 »       [SerializeField]230 »       [SerializeField]
235 »       private·SpriteRenderer·rightButton;231 »       private·SpriteRenderer·rightButton;
236 232
237 »       [SerializeField]233 »       [SerializeField]
238 »       [Space(10f)]234 »       [Space(10f)]
239 »       private·UiElement·closeButton;235 »       private·UiElement·closeButton;
240 236
241 »       [SerializeField] 
242 »       [Space(10f)]237 »       [Space(10f)]
 238 »       [SerializeField]
243 »       private·Transform·dotParent;239 »       private·Transform·dotParent;
244 240
245 »       [SerializeField]241 »       [SerializeField]
246 »       private·Transform·dotTemplate;242 »       private·Transform·dotTemplate;
247 243
248 »       [SerializeField] 
249 »       [Header("Game·Mode·Scenes")]244 »       [Header("Game·Mode·Scenes")]
 245 »       [SerializeField]
250 »       private·AbstractHowToPlayScenePage[]·classicScenes;246 »       private·AbstractHowToPlayScenePage[]·classicScenes;
251 247
252 »       [SerializeField]248 »       [SerializeField]
253 »       private·AbstractHowToPlayScenePage[]·hideAndSeekScenes;249 »       private·AbstractHowToPlayScenePage[]·hideAndSeekScenes;
254 250
255 »       [SerializeField]251 »       [SerializeField]
256 »       [Space(10f)]252 »       [Space(10f)]
4.28 KB
Assembly-CSharp/HudManager.cs
    
Offset 1, 15 lines modifiedOffset 1, 14 lines modified
1 using·System;1 using·System;
2 using·System.Collections;2 using·System.Collections;
3 using·System.Linq;3 using·System.Linq;
4 using·System.Text;4 using·System.Text;
5 using·AmongUs.Data;5 using·AmongUs.Data;
6 using·AmongUs.GameOptions;6 using·AmongUs.GameOptions;
7 using·InnerNet;7 using·InnerNet;
8 using·TMPro; 
9 using·UnityEngine;8 using·UnityEngine;
10 9
11 public·class·HudManager·:·DestroyableSingleton<HudManager>10 public·class·HudManager·:·DestroyableSingleton<HudManager>
12 {11 {
13 »       public·Coroutine·ReactorFlash·{·get;·set;·}12 »       public·Coroutine·ReactorFlash·{·get;·set;·}
14 13
15 »       public·Coroutine·OxyFlash·{·get;·set;·}14 »       public·Coroutine·OxyFlash·{·get;·set;·}
Offset 116, 14 lines modifiedOffset 115, 19 lines modified
116 »       »       if·(!MapBehaviour.Instance)115 »       »       if·(!MapBehaviour.Instance)
117 »       »       {116 »       »       {
118 »       »       »       MapBehaviour.Instance·=·Object.Instantiate<MapBehaviour>(ShipStatus.Instance.MapPrefab,·base.transform);117 »       »       »       MapBehaviour.Instance·=·Object.Instantiate<MapBehaviour>(ShipStatus.Instance.MapPrefab,·base.transform);
119 »       »       »       MapBehaviour.Instance.gameObject.SetActive(false);118 »       »       »       MapBehaviour.Instance.gameObject.SetActive(false);
120 »       »       }119 »       »       }
121 »       }120 »       }
122 121
 122 »       public·void·DeselectMapButton()
 123 »       {
 124 »       »       this.MapButton.SelectButton(false);
 125 »       }
 126
123 »       public·void·ToggleMapVisible(MapOptions·options)127 »       public·void·ToggleMapVisible(MapOptions·options)
124 »       {128 »       {
125 »       »       if·(MapBehaviour.Instance·&&·MapBehaviour.Instance.gameObject.activeSelf)129 »       »       if·(MapBehaviour.Instance·&&·MapBehaviour.Instance.gameObject.activeSelf)
126 »       »       {130 »       »       {
127 »       »       »       MapBehaviour.Instance.Close();131 »       »       »       MapBehaviour.Instance.Close();
128 »       »       »       return;132 »       »       »       return;
129 »       »       }133 »       »       }
Offset 133, 14 lines modifiedOffset 137, 15 lines modified
133 »       »       }137 »       »       }
134 »       »       if·(!ShipStatus.Instance)138 »       »       if·(!ShipStatus.Instance)
135 »       »       {139 »       »       {
136 »       »       »       return;140 »       »       »       return;
137 »       »       }141 »       »       }
138 »       »       this.InitMap();142 »       »       this.InitMap();
139 »       »       MapBehaviour.Instance.Show(options);143 »       »       MapBehaviour.Instance.Show(options);
 144 »       »       this.MapButton.SelectButton(true);
140 »       }145 »       }
141 146
142 »       public·void·SetHudActive(PlayerControl·localPlayer,·RoleBehaviour·role,·bool·isActive)147 »       public·void·SetHudActive(PlayerControl·localPlayer,·RoleBehaviour·role,·bool·isActive)
143 »       {148 »       {
144 »       »       this.AbilityButton.ToggleVisible(isActive);149 »       »       this.AbilityButton.ToggleVisible(isActive);
145 »       »       if·(isActive)150 »       »       if·(isActive)
146 »       »       {151 »       »       {
Offset 148, 17 lines modifiedOffset 153, 17 lines modified
148 »       »       »       this.AbilityButton.Refresh(role.Ability);153 »       »       »       this.AbilityButton.Refresh(role.Ability);
149 »       »       }154 »       »       }
150 »       »       else155 »       »       else
151 »       »       {156 »       »       {
152 »       »       »       this.UseButton.ToggleVisible(false);157 »       »       »       this.UseButton.ToggleVisible(false);
153 »       »       »       this.PetButton.ToggleVisible(false);158 »       »       »       this.PetButton.ToggleVisible(false);
154 »       »       }159 »       »       }
155 »       »       bool·flag·=·localPlayer.Data·!=·null·&&·localPlayer.Data.IsDead;160 »       »       bool·flag·=·!(localPlayer.Data·==·null)·&&·localPlayer.Data.IsDead;
156 »       »       this.ReportButton.ToggleVisible(isActive·&&·!flag·&&·GameManager.Instance.CanReportBodies()·&&·ShipStatus.Instance·!=·null);161 »       »       this.ReportButton.ToggleVisible(isActive·&&·!flag·&&·GameManager.Instance.CanReportBodies()·&&·ShipStatus.Instance·!=·null);
157 »       »       this.KillButton.ToggleVisible(isActive·&&·role.IsImpostor·&&·!flag);162 »       »       this.KillButton.ToggleVisible(isActive·&&·role.IsImpostor·&&·role.CanUseKillButton·&&·!flag);
158 »       »       this.SabotageButton.ToggleVisible(isActive·&&·role.IsImpostor);163 »       »       this.SabotageButton.ToggleVisible(isActive·&&·role.IsImpostor);
159 »       »       this.AdminButton.ToggleVisible(isActive·&&·role.IsImpostor);164 »       »       this.AdminButton.ToggleVisible(isActive·&&·role.IsImpostor);
160 »       »       this.ImpostorVentButton.ToggleVisible(isActive·&&·!flag·&&·role.IsImpostor·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·!=·GameModes.HideNSeek);165 »       »       this.ImpostorVentButton.ToggleVisible(isActive·&&·!flag·&&·role.IsImpostor·&&·GameOptionsManager.Instance.CurrentGameOptions.GameMode·!=·GameModes.HideNSeek);
161 »       »       this.TaskPanel.gameObject.SetActive(isActive);166 »       »       this.TaskPanel.gameObject.SetActive(isActive);
162 »       »       this.roomTracker.gameObject.SetActive(isActive);167 »       »       this.roomTracker.gameObject.SetActive(isActive);
163 »       »       if·(this.joystick·!=·null)168 »       »       if·(this.joystick·!=·null)
164 »       »       {169 »       »       {
Offset 204, 25 lines modifiedOffset 209, 29 lines modified
204 »       {209 »       {
205 »       »       if·(this.consoleUIRoot.transform.localPosition.x·!=·this.consoleUIHorizontalShift)210 »       »       if·(this.consoleUIRoot.transform.localPosition.x·!=·this.consoleUIHorizontalShift)
206 »       »       {211 »       »       {
207 »       »       »       Vector3·localPosition·=·this.consoleUIRoot.transform.localPosition;212 »       »       »       Vector3·localPosition·=·this.consoleUIRoot.transform.localPosition;
208 »       »       »       localPosition.x·=·this.consoleUIHorizontalShift;213 »       »       »       localPosition.x·=·this.consoleUIHorizontalShift;
209 »       »       »       this.consoleUIRoot.transform.localPosition·=·localPosition;214 »       »       »       this.consoleUIRoot.transform.localPosition·=·localPosition;
210 »       »       }215 »       »       }
 216 »       »       if·(this.joystickR·!=·null·&&·LobbyBehaviour.Instance·!=·null)
 217 »       »       {
 218 »       »       »       this.joystickR.ToggleVisuals(false);
 219 »       »       }
211 »       »       this.taskDirtyTimer·+=·Time.deltaTime;220 »       »       this.taskDirtyTimer·+=·Time.deltaTime;
212 »       »       if·(this.taskDirtyTimer·>·0.25f)221 »       »       if·(this.taskDirtyTimer·>·0.25f)
213 »       »       {222 »       »       {
214 »       »       »       float·num·=·this.taskDirtyTimer;223 »       »       »       float·num·=·this.taskDirtyTimer;
215 »       »       »       this.taskDirtyTimer·=·0f;224 »       »       »       this.taskDirtyTimer·=·0f;
216 »       »       »       if·(!PlayerControl.LocalPlayer)225 »       »       »       if·(!PlayerControl.LocalPlayer)
217 »       »       »       {226 »       »       »       {
218 »       »       »       »       this.TaskPanel.SetTaskText(string.Empty);227 »       »       »       »       this.TaskPanel.SetTaskText(string.Empty);
219 »       »       »       »       return;228 »       »       »       »       return;
220 »       »       »       }229 »       »       »       }
221 »       »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;230 »       »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
222 »       »       »       if·(data·==·null)231 »       »       »       if·(data·==·null)
223 »       »       »       {232 »       »       »       {
224 »       »       »       »       return;233 »       »       »       »       return;
225 »       »       »       }234 »       »       »       }
226 »       »       »       bool·flag·=·data.Role·!=·null·&&·data.Role.IsImpostor;235 »       »       »       bool·flag·=·data.Role·!=·null·&&·data.Role.IsImpostor;
227 »       »       »       this.tasksString.Clear();236 »       »       »       this.tasksString.Clear();
228 »       »       »       if·(PlayerControl.LocalPlayer.myTasks·==·null·||·PlayerControl.LocalPlayer.myTasks.Count·==·0)237 »       »       »       if·(PlayerControl.LocalPlayer.myTasks·==·null·||·PlayerControl.LocalPlayer.myTasks.Count·==·0)
Offset 428, 15 lines modifiedOffset 437, 15 lines modified
428 »       »       »       return;437 »       »       »       return;
429 »       »       }438 »       »       }
430 »       »       Debug.Log("Opening·meeting·room:·"·+·((reporter·!=·null)·?·reporter.ToString()·:·null));439 »       »       Debug.Log("Opening·meeting·room:·"·+·((reporter·!=·null)·?·reporter.ToString()·:·null));
431 »       »       ShipStatus.Instance.RepairCriticalSabotages();440 »       »       ShipStatus.Instance.RepairCriticalSabotages();
432 »       »       MeetingHud.Instance·=·Object.Instantiate<MeetingHud>(this.MeetingPrefab);441 »       »       MeetingHud.Instance·=·Object.Instantiate<MeetingHud>(this.MeetingPrefab);
433 »       »       MeetingHud.Instance.ServerStart(reporter.PlayerId);442 »       »       MeetingHud.Instance.ServerStart(reporter.PlayerId);
434 »       »       AmongUsClient.Instance.Spawn(MeetingHud.Instance,·-2,·SpawnFlags.None);443 »       »       AmongUsClient.Instance.Spawn(MeetingHud.Instance,·-2,·SpawnFlags.None);
435 »       »       TempData.OnMeetingStart();444 »       »       GameData.OnMeetingStart();
436 »       »       this.Chat.OnMeetingStart();445 »       »       this.Chat.OnMeetingStart();
437 »       }446 »       }
438 447
439 »       public·void·SetAlertOverlay(bool·enabled)448 »       public·void·SetAlertOverlay(bool·enabled)
440 »       {449 »       {
441 »       »       this.AlertFlash.SetOverlay(enabled);450 »       »       this.AlertFlash.SetOverlay(enabled);
442 »       }451 »       }
Offset 538, 16 lines modifiedOffset 547, 14 lines modified
538 547
539 »       public·PetButton·PetButton;548 »       public·PetButton·PetButton;
540 549
541 »       public·AbilityButton·AbilityButton;550 »       public·AbilityButton·AbilityButton;
542 551
543 »       public·ReportButton·ReportButton;552 »       public·ReportButton·ReportButton;
544 553
545 »       public·TextMeshPro·GameSettings; 
546  
547 »       public·GameObject·TaskStuff;554 »       public·GameObject·TaskStuff;
548 555
Max diff block lines reached; 87/4323 bytes (2.01%) of diff not shown.
2.05 KB
Assembly-CSharp/IAnalyticsReporter.cs
    
Offset 1, 28 lines modifiedOffset 1, 28 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·AmongUs.GameOptions;3 using·AmongUs.GameOptions;
4 4
5 public·interface·IAnalyticsReporter5 public·interface·IAnalyticsReporter
6 {6 {
7 »       void·StartGame(GameData.PlayerInfo·localPlayer,·int·playerCount,·int·impostorCount,·NetworkModes·networkMode,·MapNames·map,·GameModes·gameMode,·string·roomCode,·string·serverName,·IGameOptions·options,·List<GameData.PlayerInfo>·players);7 »       void·StartGame(NetworkedPlayerInfo·localPlayer,·int·playerCount,·int·impostorCount,·NetworkModes·networkMode,·MapNames·map,·GameModes·gameMode,·string·roomCode,·string·serverName,·IGameOptions·options,·List<NetworkedPlayerInfo>·players);
8 8
9 »       void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List<GameData.PlayerInfo>·players);9 »       void·EndGame(float·durationInSeconds,·GameOverReason·endReason,·List<NetworkedPlayerInfo>·players);
10 10
11 »       void·VentUsed(GameData.PlayerInfo·player);11 »       void·VentUsed(NetworkedPlayerInfo·player);
12 12
13 »       void·Kill(GameData.PlayerInfo·victim,·GameData.PlayerInfo·killer);13 »       void·Kill(NetworkedPlayerInfo·victim,·NetworkedPlayerInfo·killer);
14 14
15 »       void·SabotageStart(SystemTypes·type);15 »       void·SabotageStart(SystemTypes·type);
16 16
17 »       void·SabotageFixed(SystemTypes·type);17 »       void·SabotageFixed(SystemTypes·type);
18 18
19 »       void·TaskCompleted(GameData.PlayerInfo·player,·PlayerTask·task);19 »       void·TaskCompleted(NetworkedPlayerInfo·player,·PlayerTask·task);
20 20
21 »       void·MeetingStarted(GameData.PlayerInfo·callingPlayer,·bool·bodyReported);21 »       void·MeetingStarted(NetworkedPlayerInfo·callingPlayer,·bool·bodyReported);
22 22
23 »       void·MeetingEnded(float·durationInSeconds,·GameData.PlayerInfo·playerEjected);23 »       void·MeetingEnded(float·durationInSeconds,·NetworkedPlayerInfo·playerEjected);
24 24
25 »       void·MinigameOpened(GameData.PlayerInfo·callingPlayer,·TaskTypes·task);25 »       void·MinigameOpened(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task);
26 26
27 »       void·MinigameClosed(GameData.PlayerInfo·callingPlayer,·TaskTypes·task,·float·durationInSeconds,·bool·isCompleted);27 »       void·MinigameClosed(NetworkedPlayerInfo·callingPlayer,·TaskTypes·task,·float·durationInSeconds,·bool·isCompleted);
28 }28 }
291 B
Assembly-CSharp/IDisconnectHandler.cs
    
Offset 1, 8 lines modifiedOffset 1, 10 lines modified
1 using·System;1 using·System;
2 2
3 public·interface·IDisconnectHandler3 public·interface·IDisconnectHandler
4 {4 {
 5 »       bool·IsPersistent·{·get;·}
 6
5 »       void·HandleDisconnect(PlayerControl·pc,·DisconnectReasons·reason);7 »       void·HandleDisconnect(PlayerControl·pc,·DisconnectReasons·reason);
6 8
7 »       void·HandleDisconnect();9 »       void·HandleDisconnect();
8 }10 }
4.41 KB
Assembly-CSharp/IGameOptionsExtensions.cs
    
Offset 8, 14 lines modifiedOffset 8, 21 lines modified
8 »       public·static·void·SetRecommendations(this·IGameOptions·gameOptions,·int·numPlayers,·NetworkModes·modes)8 »       public·static·void·SetRecommendations(this·IGameOptions·gameOptions,·int·numPlayers,·NetworkModes·modes)
9 »       {9 »       {
10 »       »       numPlayers·=·Mathf.Clamp(numPlayers,·4,·15);10 »       »       numPlayers·=·Mathf.Clamp(numPlayers,·4,·15);
11 »       »       bool·flag·=·modes·==·NetworkModes.OnlineGame;11 »       »       bool·flag·=·modes·==·NetworkModes.OnlineGame;
12 »       »       gameOptions.SetRecommendations(numPlayers,·flag);12 »       »       gameOptions.SetRecommendations(numPlayers,·flag);
13 »       }13 »       }
14 14
 15 »       public·static·void·SetRecommendations(this·IGameOptions·gameOptions,·int·numPlayers,·NetworkModes·modes,·RulesPresets·rulesPresets)
 16 »       {
 17 »       »       numPlayers·=·Mathf.Clamp(numPlayers,·4,·15);
 18 »       »       bool·flag·=·modes·==·NetworkModes.OnlineGame;
 19 »       »       gameOptions.SetRecommendations(numPlayers,·flag,·rulesPresets);
 20 »       }
 21
15 »       public·static·int·GetAdjustedNumImpostors(this·IGameOptions·gameOptions,·int·playerCount)22 »       public·static·int·GetAdjustedNumImpostors(this·IGameOptions·gameOptions,·int·playerCount)
16 »       {23 »       {
17 »       »       int·numImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.NumImpostors;24 »       »       int·numImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.NumImpostors;
18 »       »       int·num·=·3;25 »       »       int·num·=·3;
19 »       »       int[]·intArray·=·gameOptions.GetIntArray(Int32ArrayOptionNames.MaxImpostors);26 »       »       int[]·intArray·=·gameOptions.GetIntArray(Int32ArrayOptionNames.MaxImpostors);
20 »       »       if·(intArray·!=·null·&&·GameData.Instance.PlayerCount·<·intArray.Length)27 »       »       if·(intArray·!=·null·&&·GameData.Instance.PlayerCount·<·intArray.Length)
21 »       »       {28 »       »       {
Offset 35, 14 lines modifiedOffset 42, 62 lines modified
35 42
36 »       public·static·bool·FilterContainsMap(this·IGameOptions·gameOptions,·byte·newId)43 »       public·static·bool·FilterContainsMap(this·IGameOptions·gameOptions,·byte·newId)
37 »       {44 »       {
38 »       »       int·num·=·1·<<·(int)newId;45 »       »       int·num·=·1·<<·(int)newId;
39 »       »       return·((int)gameOptions.MapId·&·num)·==·num;46 »       »       return·((int)gameOptions.MapId·&·num)·==·num;
40 »       }47 »       }
41 48
 49 »       public·static·float·GetValue(this·IGameOptions·gameOptions,·BaseGameSetting·data)
 50 »       {
 51 »       »       float·num·=·-1f;
 52 »       »       int·num2·=·-1;
 53 »       »       bool·flag·=·false;
 54 »       »       bool·flag2·=·false;
 55 »       »       switch·(data.Type)
 56 »       »       {
 57 »       »       case·OptionTypes.Checkbox:
 58 »       »       »       gameOptions.TryGetBool((data·as·CheckboxGameSetting).OptionName,·out·flag);
 59 »       »       »       flag2·=·true;
 60 »       »       »       goto·IL_00E7;
 61 »       »       case·OptionTypes.String:
 62 »       »       »       gameOptions.TryGetInt((data·as·StringGameSetting).OptionName,·out·num2);
 63 »       »       »       goto·IL_00E7;
 64 »       »       case·OptionTypes.Float:
 65 »       »       »       gameOptions.TryGetFloat((data·as·FloatGameSetting).OptionName,·out·num);
 66 »       »       »       goto·IL_00E7;
 67 »       »       case·OptionTypes.Int:
 68 »       »       »       gameOptions.TryGetInt((data·as·IntGameSetting).OptionName,·out·num2);
 69 »       »       »       goto·IL_00E7;
 70 »       »       case·OptionTypes.Player:
 71 »       »       »       gameOptions.TryGetInt((data·as·PlayerSelectionGameSetting).OptionName,·out·num2);
 72 »       »       »       goto·IL_00E7;
 73 »       »       case·OptionTypes.Map:
 74 »       »       {
 75 »       »       »       MapSelectionGameSetting·mapSelectionGameSetting·=·data·as·MapSelectionGameSetting;
 76 »       »       »       if·(mapSelectionGameSetting·==·null)
 77 »       »       »       {
 78 »       »       »       »       goto·IL_00E7;
 79 »       »       »       }
 80 »       »       »       mapSelectionGameSetting.TryGetInt(gameOptions,·out·num2);
 81 »       »       »       goto·IL_00E7;
 82 »       »       }
 83 »       »       }
 84 »       »       Debug.LogError("Could·not·parse·type·of·"·+·data.Title.ToString());
 85 »       »       IL_00E7:
 86 »       »       if·(num·==·-1f·&&·num2·!=·-1)
 87 »       »       {
 88 »       »       »       num·=·(float)num2;
 89 »       »       }
 90 »       »       else·if·(num·==·-1f·&&·flag2)
 91 »       »       {
 92 »       »       »       num·=·(float)((!flag)·?·0·:·1);
 93 »       »       }
 94 »       »       return·num;
 95 »       }
 96
42 »       public·static·string·ToHudString(this·IGameOptions·gameOptions,·int·numPlayers)97 »       public·static·string·ToHudString(this·IGameOptions·gameOptions,·int·numPlayers)
43 »       {98 »       {
44 »       »       int[]·array;99 »       »       int[]·array;
45 »       »       if·(!gameOptions.TryGetIntArray(Int32ArrayOptionNames.MaxImpostors,·out·array))100 »       »       if·(!gameOptions.TryGetIntArray(Int32ArrayOptionNames.MaxImpostors,·out·array))
46 »       »       {101 »       »       {
47 »       »       »       Debug.LogError("Failed·to·generate·HUD·string·for·game·options,·no·MaxImpostors·array·found");102 »       »       »       Debug.LogError("Failed·to·generate·HUD·string·for·game·options,·no·MaxImpostors·array·found");
48 »       »       »       return·"hud·string·generation·failed";103 »       »       »       return·"hud·string·generation·failed";
Offset 180, 27 lines modifiedOffset 235, 41 lines modified
180 »       »       int·id·=·options.GetInt(Int32OptionNames.ImpostorPlayerID);235 »       »       int·id·=·options.GetInt(Int32OptionNames.ImpostorPlayerID);
181 »       »       if·(id·<·0·||·isGamePublic)236 »       »       if·(id·<·0·||·isGamePublic)
182 »       »       {237 »       »       {
183 »       »       »       settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>()));238 »       »       »       settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>()));
184 »       »       }239 »       »       }
185 »       »       else240 »       »       else
186 »       »       {241 »       »       {
187 »       »       »       GameData.PlayerInfo·playerInfo·=·GameData.Instance.AllPlayers.Find((GameData.PlayerInfo·p)·=>·(int)p.PlayerId·==·id);242 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers.Find((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·id);
188 »       »       »       if·(playerInfo·!=·null)243 »       »       »       if·(networkedPlayerInfo·!=·null)
189 »       »       »       {244 »       »       »       {
190 »       »       »       »       settings.Append(playerInfo.PlayerName);245 »       »       »       »       settings.Append(networkedPlayerInfo.PlayerName);
191 »       »       »       }246 »       »       »       }
192 »       »       »       else247 »       »       »       else
193 »       »       »       {248 »       »       »       {
194 »       »       »       »       settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>()));249 »       »       »       »       settings.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>()));
195 »       »       »       }250 »       »       »       }
196 »       »       }251 »       »       }
197 »       »       settings.AppendLine();252 »       »       settings.AppendLine();
198 »       }253 »       }
199 254
 255 »       public·static·StringNames·GetRulesPresetTitle(this·IGameOptions·gameOptions)
 256 »       {
 257 »       »       RulesPresets·rulesPreset·=·gameOptions.RulesPreset;
 258 »       »       if·(rulesPreset·==·RulesPresets.Standard)
 259 »       »       {
 260 »       »       »       return·GameManager.Instance.GameSettingsList.StandardRulesName;
 261 »       »       }
 262 »       »       if·(rulesPreset·!=·RulesPresets.Custom)
 263 »       »       {
 264 »       »       »       return·GameManager.Instance.GameSettingsList.AlternateRulesName;
 265 »       »       }
 266 »       »       return·StringNames.GameModeCustom;
 267 »       }
 268
200 »       private·const·byte·SkeldBit·=·1;269 »       private·const·byte·SkeldBit·=·1;
201 270
202 »       private·const·byte·MiraBit·=·2;271 »       private·const·byte·MiraBit·=·2;
203 272
204 »       private·const·byte·PolusBit·=·4;273 »       private·const·byte·PolusBit·=·4;
205 274
206 »       private·const·byte·AirshipBit·=·16;275 »       private·const·byte·AirshipBit·=·16;
751 B
Assembly-CSharp/ImpostorRole.cs
    
Offset 65, 17 lines modifiedOffset 65, 17 lines modified
65 »       }65 »       }
66 66
67 »       public·override·bool·DidWin(GameOverReason·gameOverReason)67 »       public·override·bool·DidWin(GameOverReason·gameOverReason)
68 »       {68 »       {
69 »       »       return·GameManager.Instance.DidImpostorsWin(gameOverReason);69 »       »       return·GameManager.Instance.DidImpostorsWin(gameOverReason);
70 »       }70 »       }
71 71
72 »       protected·override·bool·IsValidTarget(GameData.PlayerInfo·target)72 »       protected·override·bool·IsValidTarget(NetworkedPlayerInfo·target)
73 »       {73 »       {
74 »       »       return·target.Role.CanBeKilled·&&·base.IsValidTarget(target);74 »       »       return·base.IsValidTarget(target)·&&·target.Role.CanBeKilled;
75 »       }75 »       }
76 76
77 »       public·override·PlayerControl·FindClosestTarget()77 »       public·override·PlayerControl·FindClosestTarget()
78 »       {78 »       {
79 »       »       List<PlayerControl>·playersInAbilityRangeSorted·=·base.GetPlayersInAbilityRangeSorted(RoleBehaviour.GetTempPlayerList());79 »       »       List<PlayerControl>·playersInAbilityRangeSorted·=·base.GetPlayersInAbilityRangeSorted(RoleBehaviour.GetTempPlayerList());
80 »       »       if·(playersInAbilityRangeSorted.Count·<=·0)80 »       »       if·(playersInAbilityRangeSorted.Count·<=·0)
81 »       »       {81 »       »       {
712 B
Assembly-CSharp/IncubateEggMinigame.cs
Ordering differences only
    
Offset 267, 27 lines modifiedOffset 267, 27 lines modified
267 267
268 »       [SerializeField]268 »       [SerializeField]
269 »       private·PassiveButton·waterBottle;269 »       private·PassiveButton·waterBottle;
270 270
271 »       [SerializeField]271 »       [SerializeField]
272 »       private·GameObject·waterFull;272 »       private·GameObject·waterFull;
273 273
274 »       [SerializeField] 
275 »       [Header("Timer")]274 »       [Header("Timer")]
 275 »       [SerializeField]
276 »       private·FungleTimer·timer;276 »       private·FungleTimer·timer;
277 277
278 »       [SerializeField] 
279 »       [Header("Glyphs")]278 »       [Header("Glyphs")]
 279 »       [SerializeField]
280 »       private·GameObject·emptyGlyphs;280 »       private·GameObject·emptyGlyphs;
281 281
282 »       [SerializeField]282 »       [SerializeField]
283 »       private·GameObject·hatchedGlyphs;283 »       private·GameObject·hatchedGlyphs;
284 284
285 »       [SerializeField] 
286 »       [Header("Audio")]285 »       [Header("Audio")]
 286 »       [SerializeField]
287 »       private·AudioClip·foodPlacedSfx;287 »       private·AudioClip·foodPlacedSfx;
288 288
289 »       [SerializeField]289 »       [SerializeField]
290 »       private·AudioClip·waterPlacedSfx;290 »       private·AudioClip·waterPlacedSfx;
291 291
292 »       [SerializeField]292 »       [SerializeField]
293 »       private·AudioClip·eggPlacedSfx;293 »       private·AudioClip·eggPlacedSfx;
939 B
Assembly-CSharp/InGamePlayerList.cs
    
Offset 183, 16 lines modifiedOffset 183, 16 lines modified
183 »       »       this.buttonPool.ReclaimAll();183 »       »       this.buttonPool.ReclaimAll();
184 »       »       for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++)184 »       »       for·(int·i·=·0;·i·<·GameData.Instance.AllPlayers.Count;·i++)
185 »       »       {185 »       »       {
186 »       »       »       PlayerIdentifierButton·component·=·this.buttonPool.Get<PoolableBehavior>().GetComponent<PlayerIdentifierButton>();186 »       »       »       PlayerIdentifierButton·component·=·this.buttonPool.Get<PoolableBehavior>().GetComponent<PlayerIdentifierButton>();
187 »       »       »       Vector3·vector·=·new·Vector3(0f,·-this.buttonHeight·*·(float)i,·0f);187 »       »       »       Vector3·vector·=·new·Vector3(0f,·-this.buttonHeight·*·(float)i,·0f);
188 »       »       »       component.transform.localPosition·=·vector;188 »       »       »       component.transform.localPosition·=·vector;
189 »       »       »       component.transform.localScale·=·Vector3.one;189 »       »       »       component.transform.localScale·=·Vector3.one;
190 »       »       »       GameData.PlayerInfo·playerInfo·=·GameData.Instance.AllPlayers[i];190 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers[i];
191 »       »       »       component.Populate(playerInfo);191 »       »       »       component.Populate(networkedPlayerInfo);
192 »       »       »       UiElement·componentInChildren·=·component.GetComponentInChildren<UiElement>(true);192 »       »       »       UiElement·componentInChildren·=·component.GetComponentInChildren<UiElement>(true);
193 »       »       »       this.controllerNavMenu.ControllerSelectable.Add(componentInChildren);193 »       »       »       this.controllerNavMenu.ControllerSelectable.Add(componentInChildren);
194 »       »       }194 »       »       }
195 »       }195 »       }
196 196
197 »       public·Vector3·offsetFromEdge;197 »       public·Vector3·offsetFromEdge;
198 198
407 B
Assembly-CSharp/InnerNet/ClientData.cs
    
Offset 24, 14 lines modifiedOffset 24, 16 lines modified
24 24
25 »       »       public·bool·InScene;25 »       »       public·bool·InScene;
26 26
27 »       »       public·bool·IsReady;27 »       »       public·bool·IsReady;
28 28
29 »       »       public·bool·HasBeenReported;29 »       »       public·bool·HasBeenReported;
30 30
 31 »       »       public·bool·IsBeingCreated;
 32
31 »       »       public·PlayerControl·Character;33 »       »       public·PlayerControl·Character;
32 34
33 »       »       public·readonly·uint·PlayerLevel·=·1U;35 »       »       public·readonly·uint·PlayerLevel·=·1U;
34 36
35 »       »       public·readonly·PlatformSpecificData·PlatformData;37 »       »       public·readonly·PlatformSpecificData·PlatformData;
36 38
37 »       »       public·string·PlayerName·=·"???";39 »       »       public·string·PlayerName·=·"???";
18.6 KB
Assembly-CSharp/InnerNet/InnerNetClient.cs
    
Offset 203, 33 lines modifiedOffset 203, 33 lines modified
203 »       »       »       {203 »       »       »       {
204 »       »       »       »       yield·break;204 »       »       »       »       yield·break;
205 »       »       »       }205 »       »       »       }
206 »       »       »       ClientData·clientData·=·this.FindClientById(this.ClientId);206 »       »       »       ClientData·clientData·=·this.FindClientById(this.ClientId);
207 »       »       »       if·(clientData·!=·null)207 »       »       »       if·(clientData·!=·null)
208 »       »       »       {208 »       »       »       {
209 »       »       »       »       Debug.Log(string.Format("Self·changed·scene:·{0}·{1}",·this.ClientId,·sceneName));209 »       »       »       »       Debug.Log(string.Format("Self·changed·scene:·{0}·{1}",·this.ClientId,·sceneName));
 210 »       »       »       »       if·(this.connection.State·==·ConnectionState.Connected)
 211 »       »       »       »       {
 212 »       »       »       »       »       MessageWriter·messageWriter·=·MessageWriter.Get(SendOption.Reliable);
 213 »       »       »       »       »       messageWriter.StartMessage(5);
 214 »       »       »       »       »       messageWriter.Write(this.GameId);
 215 »       »       »       »       »       messageWriter.StartMessage(6);
 216 »       »       »       »       »       messageWriter.WritePacked(this.ClientId);
 217 »       »       »       »       »       messageWriter.Write(sceneName);
 218 »       »       »       »       »       messageWriter.EndMessage();
 219 »       »       »       »       »       messageWriter.EndMessage();
 220 »       »       »       »       »       this.SendOrDisconnect(messageWriter);
 221 »       »       »       »       »       messageWriter.Recycle();
 222 »       »       »       »       }
210 »       »       »       »       yield·return·this.CoOnPlayerChangedScene(clientData,·sceneName);223 »       »       »       »       yield·return·this.CoOnPlayerChangedScene(clientData,·sceneName);
211 »       »       »       }224 »       »       »       }
212 »       »       »       else225 »       »       »       else
213 »       »       »       {226 »       »       »       {
214 »       »       »       »       Debug.Log(string.Format("Couldn't·find·self·in·clients:·{0}:·",·this.ClientId)·+·sceneName);227 »       »       »       »       Debug.Log(string.Format("Couldn't·find·self·in·clients:·{0}:·",·this.ClientId)·+·sceneName);
215 »       »       »       }228 »       »       »       }
216 »       »       »       if·(!this.AmHost·&&·this.connection.State·==·ConnectionState.Connected) 
217 »       »       »       { 
218 »       »       »       »       MessageWriter·messageWriter·=·MessageWriter.Get(SendOption.Reliable); 
219 »       »       »       »       messageWriter.StartMessage(5); 
220 »       »       »       »       messageWriter.Write(this.GameId); 
221 »       »       »       »       messageWriter.StartMessage(6); 
222 »       »       »       »       messageWriter.WritePacked(this.ClientId); 
223 »       »       »       »       messageWriter.Write(sceneName); 
224 »       »       »       »       messageWriter.EndMessage(); 
225 »       »       »       »       messageWriter.EndMessage(); 
226 »       »       »       »       this.SendOrDisconnect(messageWriter); 
227 »       »       »       »       messageWriter.Recycle(); 
228 »       »       »       } 
229 »       »       »       yield·break;229 »       »       »       yield·break;
230 »       »       }230 »       »       }
231 231
232 »       »       public·void·Spawn(InnerNetObject·netObjParent,·int·ownerId·=·-2,·SpawnFlags·flags·=·SpawnFlags.None)232 »       »       public·void·Spawn(InnerNetObject·netObjParent,·int·ownerId·=·-2,·SpawnFlags·flags·=·SpawnFlags.None)
233 »       »       {233 »       »       {
234 »       »       »       if·(this.AmHost)234 »       »       »       if·(this.AmHost)
235 »       »       »       {235 »       »       »       {
Offset 287, 15 lines modifiedOffset 287, 15 lines modified
287 »       »       »       messageWriter.EndMessage();287 »       »       »       messageWriter.EndMessage();
288 »       »       »       this.RemoveNetObject(objToDespawn);288 »       »       »       this.RemoveNetObject(objToDespawn);
289 »       »       }289 »       »       }
290 290
291 »       »       private·bool·AddNetObject(InnerNetObject·obj)291 »       »       private·bool·AddNetObject(InnerNetObject·obj)
292 »       »       {292 »       »       {
293 »       »       »       uint·num·=·obj.NetId·+·1U;293 »       »       »       uint·num·=·obj.NetId·+·1U;
294 »       »       »       if·(num·>·this.NetIdCnt)294 »       »       »       if·(num·>·this.NetIdCnt·&&·num·<·100000U)
295 »       »       »       {295 »       »       »       {
296 »       »       »       »       this.NetIdCnt·=·num;296 »       »       »       »       this.NetIdCnt·=·num;
297 »       »       »       }297 »       »       »       }
298 »       »       »       if·(!this.allObjectsFast.ContainsKey(obj.NetId))298 »       »       »       if·(!this.allObjectsFast.ContainsKey(obj.NetId))
299 »       »       »       {299 »       »       »       {
300 »       »       »       »       this.allObjects.Add(obj);300 »       »       »       »       this.allObjects.Add(obj);
301 »       »       »       »       this.allObjectsFast.Add(obj.NetId,·obj);301 »       »       »       »       this.allObjectsFast.Add(obj.NetId,·obj);
Offset 315, 14 lines modifiedOffset 315, 15 lines modified
315 »       »       »       obj.NetId·=·uint.MaxValue;315 »       »       »       obj.NetId·=·uint.MaxValue;
316 »       »       }316 »       »       }
317 317
318 »       »       public·void·RemoveUnownedObjects()318 »       »       public·void·RemoveUnownedObjects()
319 »       »       {319 »       »       {
320 »       »       »       HashSet<int>·hashSet·=·new·HashSet<int>();320 »       »       »       HashSet<int>·hashSet·=·new·HashSet<int>();
321 »       »       »       hashSet.Add(-2);321 »       »       »       hashSet.Add(-2);
 322 »       »       »       hashSet.Add(-4);
322 »       »       »       List<ClientData>·list·=·this.allClients;323 »       »       »       List<ClientData>·list·=·this.allClients;
323 »       »       »       lock·(list)324 »       »       »       lock·(list)
324 »       »       »       {325 »       »       »       {
325 »       »       »       »       for·(int·i·=·0;·i·<·this.allClients.Count;·i++)326 »       »       »       »       for·(int·i·=·0;·i·<·this.allClients.Count;·i++)
326 »       »       »       »       {327 »       »       »       »       {
327 »       »       »       »       »       ClientData·clientData·=·this.allClients[i];328 »       »       »       »       »       ClientData·clientData·=·this.allClients[i];
328 »       »       »       »       »       if·(clientData.Character)329 »       »       »       »       »       if·(clientData.Character)
Offset 786, 15 lines modifiedOffset 787, 15 lines modified
786 »       »       »       »       »       »       return·clientData;787 »       »       »       »       »       »       return·clientData;
787 »       »       »       »       »       }788 »       »       »       »       »       }
788 »       »       »       »       }789 »       »       »       »       }
789 »       »       »       }790 »       »       »       }
790 »       »       »       return·null;791 »       »       »       return·null;
791 »       »       }792 »       »       }
792 793
793 »       »       public·ClientData·GetClientFromCharacter(InnerNetObject·character)794 »       »       public·ClientData·GetClientFromCharacter(PlayerControl·character)
794 »       »       {795 »       »       {
795 »       »       »       if·(!character)796 »       »       »       if·(!character)
796 »       »       »       {797 »       »       »       {
797 »       »       »       »       return·null;798 »       »       »       »       return·null;
798 »       »       »       }799 »       »       »       }
799 »       »       »       List<ClientData>·list·=·this.allClients;800 »       »       »       List<ClientData>·list·=·this.allClients;
800 »       »       »       lock·(list)801 »       »       »       lock·(list)
Offset 807, 15 lines modifiedOffset 808, 36 lines modified
807 »       »       »       »       »       »       return·clientData;808 »       »       »       »       »       »       return·clientData;
808 »       »       »       »       »       }809 »       »       »       »       »       }
809 »       »       »       »       }810 »       »       »       »       }
810 »       »       »       }811 »       »       »       }
811 »       »       »       return·null;812 »       »       »       return·null;
812 »       »       }813 »       »       }
813 814
 815 »       »       public·ClientData·GetClientFromPlayerInfo(NetworkedPlayerInfo·playerInfo)
 816 »       »       {
 817 »       »       »       if·(playerInfo·==·null)
 818 »       »       »       {
 819 »       »       »       »       return·null;
 820 »       »       »       }
 821 »       »       »       List<ClientData>·list·=·this.allClients;
 822 »       »       »       lock·(list)
 823 »       »       »       {
 824 »       »       »       »       for·(int·i·=·0;·i·<·this.allClients.Count;·i++)
 825 »       »       »       »       {
 826 »       »       »       »       »       ClientData·clientData·=·this.allClients[i];
 827 »       »       »       »       »       if·(clientData.Id·==·playerInfo.ClientId)
 828 »       »       »       »       »       {
 829 »       »       »       »       »       »       return·clientData;
 830 »       »       »       »       »       }
 831 »       »       »       »       }
 832 »       »       »       }
 833 »       »       »       return·null;
 834 »       »       }
 835
814 »       »       public·int·GetClientIdFromCharacter(InnerNetObject·character)836 »       »       public·int·GetClientIdFromCharacter(PlayerControl·character)
815 »       »       {837 »       »       {
816 »       »       »       ClientData·clientFromCharacter·=·this.GetClientFromCharacter(character);838 »       »       »       ClientData·clientFromCharacter·=·this.GetClientFromCharacter(character);
817 »       »       »       if·(clientFromCharacter·==·null)839 »       »       »       if·(clientFromCharacter·==·null)
Max diff block lines reached; 15259/18945 bytes (80.54%) of diff not shown.
336 B
Assembly-CSharp/InnerNet/Tags.cs
    
Offset 44, 10 lines modifiedOffset 44, 12 lines modified
44 44
45 »       »       public·const·byte·SetActivePodType·=·21;45 »       »       public·const·byte·SetActivePodType·=·21;
46 46
47 »       »       public·const·byte·QueryPlatformIds·=·22;47 »       »       public·const·byte·QueryPlatformIds·=·22;
48 48
49 »       »       public·const·byte·QueryLobbyInfo·=·23;49 »       »       public·const·byte·QueryLobbyInfo·=·23;
50 50
 51 »       »       public·const·byte·EndGameHostMigration·=·24;
 52
51 »       »       public·const·byte·ServerDebugAlert·=·255;53 »       »       public·const·byte·ServerDebugAlert·=·255;
52 »       }54 »       }
53 }55 }
554 B
Assembly-CSharp/Innersloth/Assets/AddressableSpriteBehavior.cs
    
Offset 72, 15 lines modifiedOffset 72, 18 lines modified
72 »       »       »       »       return;72 »       »       »       »       return;
73 »       »       »       }73 »       »       »       }
74 »       »       »       addressableAsset.Unload();74 »       »       »       addressableAsset.Unload();
75 »       »       }75 »       »       }
76 76
77 »       »       private·void·OnAssetLoaded()77 »       »       private·void·OnAssetLoaded()
78 »       »       {78 »       »       {
 79 »       »       »       if·(this.spriteRenderer·!=·null)
 80 »       »       »       {
79 »       »       »       this.spriteRenderer.sprite·=·this.asset.GetAsset();81 »       »       »       »       this.spriteRenderer.sprite·=·this.asset.GetAsset();
 82 »       »       »       }
80 »       »       }83 »       »       }
81 84
82 »       »       public·bool·unloadOnDisable·=·true;85 »       »       public·bool·unloadOnDisable·=·true;
83 86
84 »       »       private·AddressableAsset<Sprite>·asset;87 »       »       private·AddressableAsset<Sprite>·asset;
85 88
86 »       »       private·SpriteRenderer·spriteRenderer;89 »       »       private·SpriteRenderer·spriteRenderer;
540 B
Assembly-CSharp/Innersloth/DebugTool/DebugCommandOverlayPage.cs
Ordering differences only
    
Offset 553, 16 lines modifiedOffset 553, 16 lines modified
553 553
554 »       »       [SerializeField]554 »       »       [SerializeField]
555 »       »       private·Transform·commandButtonParent;555 »       »       private·Transform·commandButtonParent;
556 556
557 »       »       [SerializeField]557 »       »       [SerializeField]
558 »       »       private·ScrollRect·commandScrollList;558 »       »       private·ScrollRect·commandScrollList;
559 559
560 »       »       [SerializeField] 
561 »       »       [Header("Details")]560 »       »       [Header("Details")]
 561 »       »       [SerializeField]
562 »       »       private·GameObject·detailsParent;562 »       »       private·GameObject·detailsParent;
563 563
564 »       »       [SerializeField]564 »       »       [SerializeField]
565 »       »       private·TextMeshProUGUI·basePath;565 »       »       private·TextMeshProUGUI·basePath;
566 566
567 »       »       [SerializeField]567 »       »       [SerializeField]
568 »       »       private·TextMeshProUGUI·commandName;568 »       »       private·TextMeshProUGUI·commandName;
972 B
Assembly-CSharp/Innersloth/DebugTool/DebugOverlay.cs
    
Offset 86, 25 lines modifiedOffset 86, 25 lines modified
86 »       »       »       »       if·(debugToolInputProvider.GetToggle())86 »       »       »       »       if·(debugToolInputProvider.GetToggle())
87 »       »       »       »       {87 »       »       »       »       {
88 »       »       »       »       »       this.ToggleUIVisible(!this.UIVisible);88 »       »       »       »       »       this.ToggleUIVisible(!this.UIVisible);
89 »       »       »       »       »       break;89 »       »       »       »       »       break;
90 »       »       »       »       }90 »       »       »       »       }
91 »       »       »       »       if·(this.UIVisible·&&·!this.SubpageConsumingNavActions)91 »       »       »       »       if·(this.UIVisible·&&·!this.SubpageConsumingNavActions)
92 »       »       »       »       {92 »       »       »       »       {
93 »       »       »       »       »       if·(debugToolInputProvider.GetNavLeft())93 »       »       »       »       »       if·(debugToolInputProvider.GetPagePrevious())
94 »       »       »       »       »       {94 »       »       »       »       »       {
95 »       »       »       »       »       »       this.activeTabIndex--;95 »       »       »       »       »       »       this.activeTabIndex--;
96 »       »       »       »       »       »       if·(this.activeTabIndex·<·0)96 »       »       »       »       »       »       if·(this.activeTabIndex·<·0)
97 »       »       »       »       »       »       {97 »       »       »       »       »       »       {
98 »       »       »       »       »       »       »       this.activeTabIndex·=·this.totalTabs·-·1;98 »       »       »       »       »       »       »       this.activeTabIndex·=·this.totalTabs·-·1;
99 »       »       »       »       »       »       }99 »       »       »       »       »       »       }
100 »       »       »       »       »       »       this.ShowPage(this.tabButtons[this.activeTabIndex].PageName);100 »       »       »       »       »       »       this.ShowPage(this.tabButtons[this.activeTabIndex].PageName);
101 »       »       »       »       »       »       break;101 »       »       »       »       »       »       break;
102 »       »       »       »       »       }102 »       »       »       »       »       }
103 »       »       »       »       »       if·(debugToolInputProvider.GetNavRight())103 »       »       »       »       »       if·(debugToolInputProvider.GetPageNext())
104 »       »       »       »       »       {104 »       »       »       »       »       {
105 »       »       »       »       »       »       this.activeTabIndex++;105 »       »       »       »       »       »       this.activeTabIndex++;
106 »       »       »       »       »       »       if·(this.activeTabIndex·>=·this.totalTabs)106 »       »       »       »       »       »       if·(this.activeTabIndex·>=·this.totalTabs)
107 »       »       »       »       »       »       {107 »       »       »       »       »       »       {
108 »       »       »       »       »       »       »       this.activeTabIndex·=·0;108 »       »       »       »       »       »       »       this.activeTabIndex·=·0;
109 »       »       »       »       »       »       }109 »       »       »       »       »       »       }
110 »       »       »       »       »       »       this.ShowPage(this.tabButtons[this.activeTabIndex].PageName);110 »       »       »       »       »       »       this.ShowPage(this.tabButtons[this.activeTabIndex].PageName);
673 B
Assembly-CSharp/Innersloth/DebugTool/DebugTapToOpenButton.cs
    
Offset 12, 14 lines modifiedOffset 12, 19 lines modified
12 »       »       »       this.tapButton.onClick.AddListener(new·UnityAction(this.Tap));12 »       »       »       this.tapButton.onClick.AddListener(new·UnityAction(this.Tap));
13 »       »       »       this.debugOverlay.AddToggleActiveCallback(delegate(bool·visible)13 »       »       »       this.debugOverlay.AddToggleActiveCallback(delegate(bool·visible)
14 »       »       »       {14 »       »       »       {
15 »       »       »       »       this.tapButton.gameObject.SetActive(!visible);15 »       »       »       »       this.tapButton.gameObject.SetActive(!visible);
16 »       »       »       });16 »       »       »       });
17 »       »       }17 »       »       }
18 18
 19 »       »       public·void·SetRaycastTarget(bool·raycast)
 20 »       »       {
 21 »       »       »       this.tapButton.GetComponent<Image>().raycastTarget·=·raycast;
 22 »       »       }
 23
19 »       »       private·void·Tap()24 »       »       private·void·Tap()
20 »       »       {25 »       »       {
21 »       »       »       float·time·=·Time.time;26 »       »       »       float·time·=·Time.time;
22 »       »       »       if·(this.numTapsSoFar·>·0·&&·time·-·this.lastTapTime·<=·this.maxSecondsBetweenTaps)27 »       »       »       if·(this.numTapsSoFar·>·0·&&·time·-·this.lastTapTime·<=·this.maxSecondsBetweenTaps)
23 »       »       »       {28 »       »       »       {
24 »       »       »       »       this.numTapsSoFar++;29 »       »       »       »       this.numTapsSoFar++;
25 »       »       »       }30 »       »       »       }
341 B
Assembly-CSharp/Innersloth/DebugTool/IDebugToolInputProvider.cs
    
Offset 15, 12 lines modifiedOffset 15, 16 lines modified
15 15
16 »       »       bool·GetClear();16 »       »       bool·GetClear();
17 17
18 »       »       bool·GetConfirm();18 »       »       bool·GetConfirm();
19 19
20 »       »       bool·GetCancel();20 »       »       bool·GetCancel();
21 21
 22 »       »       bool·GetPagePrevious();
 23
 24 »       »       bool·GetPageNext();
 25
22 »       »       bool·GetNavLeft();26 »       »       bool·GetNavLeft();
23 27
24 »       »       bool·GetNavRight();28 »       »       bool·GetNavRight();
25 »       }29 »       }
26 }30 }
5.11 KB
Assembly-CSharp/IntroCutscene.cs
    
Offset 17, 15 lines modifiedOffset 17, 15 lines modified
17 »       »       »       global::Logger.GlobalInstance.Info("IntroCutscene·::·CoBegin()·::·Game·Mode:·Normal",·null);17 »       »       »       global::Logger.GlobalInstance.Info("IntroCutscene·::·CoBegin()·::·Game·Mode:·Normal",·null);
18 »       »       »       this.LogPlayerRoleData();18 »       »       »       this.LogPlayerRoleData();
19 »       »       »       this.HideAndSeekPanels.SetActive(false);19 »       »       »       this.HideAndSeekPanels.SetActive(false);
20 »       »       »       this.CrewmateRules.SetActive(false);20 »       »       »       this.CrewmateRules.SetActive(false);
21 »       »       »       this.ImpostorRules.SetActive(false);21 »       »       »       this.ImpostorRules.SetActive(false);
22 »       »       »       this.ImpostorName.gameObject.SetActive(false);22 »       »       »       this.ImpostorName.gameObject.SetActive(false);
23 »       »       »       this.ImpostorTitle.gameObject.SetActive(false);23 »       »       »       this.ImpostorTitle.gameObject.SetActive(false);
24 »       »       »       List<PlayerControl>·list·=·IntroCutscene.SelectTeamToShow((GameData.PlayerInfo·pcd)·=>·!PlayerControl.LocalPlayer.Data.Role.IsImpostor·||·pcd.Role.TeamType·==·PlayerControl.LocalPlayer.Data.Role.TeamType);24 »       »       »       List<PlayerControl>·list·=·IntroCutscene.SelectTeamToShow((NetworkedPlayerInfo·pcd)·=>·!PlayerControl.LocalPlayer.Data.Role.IsImpostor·||·pcd.Role.TeamType·==·PlayerControl.LocalPlayer.Data.Role.TeamType);
25 »       »       »       if·(list·==·null·||·list.Count·<·1)25 »       »       »       if·(list·==·null·||·list.Count·<·1)
26 »       »       »       {26 »       »       »       {
27 »       »       »       »       global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null);27 »       »       »       »       global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null);
28 »       »       »       }28 »       »       »       }
29 »       »       »       if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor)29 »       »       »       if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor)
30 »       »       »       {30 »       »       »       {
31 »       »       »       »       this.ImpostorText.gameObject.SetActive(false);31 »       »       »       »       this.ImpostorText.gameObject.SetActive(false);
Offset 58, 15 lines modifiedOffset 58, 15 lines modified
58 »       »       »       »       this.ImpostorRules.SetActive(true);58 »       »       »       »       this.ImpostorRules.SetActive(true);
59 »       »       »       }59 »       »       »       }
60 »       »       »       else60 »       »       »       else
61 »       »       »       {61 »       »       »       {
62 »       »       »       »       this.CrewmateRules.SetActive(true);62 »       »       »       »       this.CrewmateRules.SetActive(true);
63 »       »       »       »       this.ImpostorRules.SetActive(false);63 »       »       »       »       this.ImpostorRules.SetActive(false);
64 »       »       »       }64 »       »       »       }
65 »       »       »       List<PlayerControl>·list2·=·IntroCutscene.SelectTeamToShow((GameData.PlayerInfo·pcd)·=>·PlayerControl.LocalPlayer.Data.Role.IsImpostor·!=·pcd.Role.IsImpostor);65 »       »       »       List<PlayerControl>·list2·=·IntroCutscene.SelectTeamToShow((NetworkedPlayerInfo·pcd)·=>·PlayerControl.LocalPlayer.Data.Role.IsImpostor·!=·pcd.Role.IsImpostor);
66 »       »       »       if·(list2·==·null·||·list2.Count·<·1)66 »       »       »       if·(list2·==·null·||·list2.Count·<·1)
67 »       »       »       {67 »       »       »       {
68 »       »       »       »       global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null);68 »       »       »       »       global::Logger.GlobalInstance.Error("IntroCutscene·::·CoBegin()·::·teamToShow·is·EMPTY·or·NULL",·null);
69 »       »       »       }69 »       »       »       }
70 »       »       »       PlayerControl·impostor·=·PlayerControl.AllPlayerControls.Find((PlayerControl·pc)·=>·pc.Data.Role.IsImpostor);70 »       »       »       PlayerControl·impostor·=·PlayerControl.AllPlayerControls.Find((PlayerControl·pc)·=>·pc.Data.Role.IsImpostor);
71 »       »       »       if·(impostor·==·null)71 »       »       »       if·(impostor·==·null)
72 »       »       »       {72 »       »       »       {
Offset 188, 17 lines modifiedOffset 188, 17 lines modified
188 »       »       if·(this.HideAndSeekPlayerVisual.HasHat())188 »       »       if·(this.HideAndSeekPlayerVisual.HasHat())
189 »       »       {189 »       »       {
190 »       »       »       this.HideAndSeekPlayerVisual.GetHandHat().gameObject.SetActive(true);190 »       »       »       this.HideAndSeekPlayerVisual.GetHandHat().gameObject.SetActive(true);
191 »       »       »       this.HideAndSeekPlayerVisual.ToggleHat(true);191 »       »       »       this.HideAndSeekPlayerVisual.ToggleHat(true);
192 »       »       }192 »       »       }
193 »       }193 »       }
194 194
195 »       private·static·List<PlayerControl>·SelectTeamToShow(Func<GameData.PlayerInfo,·bool>·roleFilter)195 »       private·static·List<PlayerControl>·SelectTeamToShow(Func<NetworkedPlayerInfo,·bool>·roleFilter)
196 »       {196 »       {
197 »       »       return·Enumerable.ToList<PlayerControl>(Enumerable.OrderBy<PlayerControl,·int>(Enumerable.Select<GameData.PlayerInfo,·PlayerControl>(Enumerable.Where<GameData.PlayerInfo>(GameData.Instance.AllPlayers,·(GameData.PlayerInfo·pcd)·=>·!pcd.Disconnected·&&·roleFilter(pcd)),·(GameData.PlayerInfo·pcd)·=>·pcd.Object),·delegate(PlayerControl·pc)197 »       »       return·Enumerable.ToList<PlayerControl>(Enumerable.OrderBy<PlayerControl,·int>(Enumerable.Select<NetworkedPlayerInfo,·PlayerControl>(Enumerable.Where<NetworkedPlayerInfo>(GameData.Instance.AllPlayers,·(NetworkedPlayerInfo·pcd)·=>·!pcd.Disconnected·&&·roleFilter(pcd)),·(NetworkedPlayerInfo·pcd)·=>·pcd.Object),·delegate(PlayerControl·pc)
198 »       »       {198 »       »       {
199 »       »       »       if·(!(pc·==·PlayerControl.LocalPlayer))199 »       »       »       if·(!(pc·==·PlayerControl.LocalPlayer))
200 »       »       »       {200 »       »       »       {
201 »       »       »       »       return·1;201 »       »       »       »       return·1;
202 »       »       »       }202 »       »       »       }
203 »       »       »       return·0;203 »       »       »       return·0;
204 »       »       }));204 »       »       }));
Offset 266, 16 lines modifiedOffset 266, 16 lines modified
266 »       »       this.TeamTitle.color·=·Palette.CrewmateBlue;266 »       »       this.TeamTitle.color·=·Palette.CrewmateBlue;
267 »       »       int·num·=·Mathf.CeilToInt(7.5f);267 »       »       int·num·=·Mathf.CeilToInt(7.5f);
268 »       »       for·(int·i·=·0;·i·<·teamToDisplay.Count;·i++)268 »       »       for·(int·i·=·0;·i·<·teamToDisplay.Count;·i++)
269 »       »       {269 »       »       {
270 »       »       »       PlayerControl·playerControl·=·teamToDisplay[i];270 »       »       »       PlayerControl·playerControl·=·teamToDisplay[i];
271 »       »       »       if·(playerControl)271 »       »       »       if·(playerControl)
272 »       »       »       {272 »       »       »       {
273 »       »       »       »       GameData.PlayerInfo·data·=·playerControl.Data;273 »       »       »       »       NetworkedPlayerInfo·data·=·playerControl.Data;
274 »       »       »       »       if·(data·!=·null)274 »       »       »       »       if·(!(data·==·null))
275 »       »       »       »       {275 »       »       »       »       {
276 »       »       »       »       »       PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·num,·data,·false);276 »       »       »       »       »       PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·num,·data,·false);
277 »       »       »       »       »       if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId)277 »       »       »       »       »       if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId)
278 »       »       »       »       »       {278 »       »       »       »       »       {
279 »       »       »       »       »       »       this.ourCrewmate·=·poolablePlayer;279 »       »       »       »       »       »       this.ourCrewmate·=·poolablePlayer;
280 »       »       »       »       »       }280 »       »       »       »       »       }
281 »       »       »       »       }281 »       »       »       »       }
Offset 288, 16 lines modifiedOffset 288, 16 lines modified
288 »       »       this.TeamTitle.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Impostor,·Array.Empty<object>());288 »       »       this.TeamTitle.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Impostor,·Array.Empty<object>());
289 »       »       this.TeamTitle.color·=·Palette.ImpostorRed;289 »       »       this.TeamTitle.color·=·Palette.ImpostorRed;
290 »       »       for·(int·i·=·0;·i·<·yourTeam.Count;·i++)290 »       »       for·(int·i·=·0;·i·<·yourTeam.Count;·i++)
291 »       »       {291 »       »       {
292 »       »       »       PlayerControl·playerControl·=·yourTeam[i];292 »       »       »       PlayerControl·playerControl·=·yourTeam[i];
293 »       »       »       if·(playerControl)293 »       »       »       if·(playerControl)
294 »       »       »       {294 »       »       »       {
295 »       »       »       »       GameData.PlayerInfo·data·=·playerControl.Data;295 »       »       »       »       NetworkedPlayerInfo·data·=·playerControl.Data;
296 »       »       »       »       if·(data·!=·null)296 »       »       »       »       if·(!(data·==·null))
297 »       »       »       »       {297 »       »       »       »       {
298 »       »       »       »       »       PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·1,·data,·true);298 »       »       »       »       »       PoolablePlayer·poolablePlayer·=·this.CreatePlayer(i,·1,·data,·true);
299 »       »       »       »       »       if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId)299 »       »       »       »       »       if·(i·==·0·&&·data.PlayerId·==·PlayerControl.LocalPlayer.PlayerId)
300 »       »       »       »       »       {300 »       »       »       »       »       {
301 »       »       »       »       »       »       this.ourCrewmate·=·poolablePlayer;301 »       »       »       »       »       »       this.ourCrewmate·=·poolablePlayer;
302 »       »       »       »       »       }302 »       »       »       »       »       }
303 »       »       »       »       }303 »       »       »       »       }
Offset 339, 15 lines modifiedOffset 339, 15 lines modified
339 »       »       if·(this.overlayHandle·!=·null)339 »       »       if·(this.overlayHandle·!=·null)
340 »       »       {340 »       »       {
341 »       »       »       this.overlayHandle.Dispose();341 »       »       »       this.overlayHandle.Dispose();
342 »       »       »       this.overlayHandle·=·null;342 »       »       »       this.overlayHandle·=·null;
343 »       »       }343 »       »       }
344 »       }344 »       }
345 345
346 »       private·PoolablePlayer·CreatePlayer(int·i,·int·maxDepth,·GameData.PlayerInfo·pData,·bool·impostorPositioning)346 »       private·PoolablePlayer·CreatePlayer(int·i,·int·maxDepth,·NetworkedPlayerInfo·pData,·bool·impostorPositioning)
347 »       {347 »       {
348 »       »       int·num·=·((i·%·2·==·0)·?·(-1)·:·1);348 »       »       int·num·=·((i·%·2·==·0)·?·(-1)·:·1);
349 »       »       int·num2·=·(i·+·1)·/·2;349 »       »       int·num2·=·(i·+·1)·/·2;
350 »       »       float·num3·=·(float)((i·==·0)·?·(-8)·:·(-1));350 »       »       float·num3·=·(float)((i·==·0)·?·(-8)·:·(-1));
351 »       »       PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform);351 »       »       PoolablePlayer·poolablePlayer·=·Object.Instantiate<PoolablePlayer>(this.PlayerPrefab,·base.transform);
352 »       »       poolablePlayer.name·=·pData.PlayerName·+·"Dummy";352 »       »       poolablePlayer.name·=·pData.PlayerName·+·"Dummy";
353 »       »       poolablePlayer.SetFlipX(i·%·2·==·0);353 »       »       poolablePlayer.SetFlipX(i·%·2·==·0);
365 B
Assembly-CSharp/IUsable.cs
    
Offset 6, 11 lines modifiedOffset 6, 11 lines modified
6 6
7 »       float·PercentCool·{·get;·}7 »       float·PercentCool·{·get;·}
8 8
9 »       ImageNames·UseIcon·{·get;·}9 »       ImageNames·UseIcon·{·get;·}
10 10
11 »       void·SetOutline(bool·on,·bool·mainTarget);11 »       void·SetOutline(bool·on,·bool·mainTarget);
12 12
13 »       float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse);13 »       float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse);
14 14
15 »       void·Use();15 »       void·Use();
16 }16 }
519 B
Assembly-CSharp/KeyboardDebugToolInputProvider.cs
    
Offset 45, 14 lines modifiedOffset 45, 24 lines modified
45 »       }45 »       }
46 46
47 »       public·bool·GetCancel()47 »       public·bool·GetCancel()
48 »       {48 »       {
49 »       »       return·Input.GetKeyUp(KeyCode.Escape);49 »       »       return·Input.GetKeyUp(KeyCode.Escape);
50 »       }50 »       }
51 51
 52 »       public·bool·GetPagePrevious()
 53 »       {
 54 »       »       return·Input.GetKey(KeyCode.Q);
 55 »       }
 56
 57 »       public·bool·GetPageNext()
 58 »       {
 59 »       »       return·Input.GetKey(KeyCode.E);
 60 »       }
 61
52 »       public·bool·GetNavLeft()62 »       public·bool·GetNavLeft()
53 »       {63 »       {
54 »       »       return·Input.GetKey(KeyCode.LeftShift)·&&·Input.GetKeyUp(KeyCode.Tab);64 »       »       return·Input.GetKey(KeyCode.LeftShift)·&&·Input.GetKeyUp(KeyCode.Tab);
55 »       }65 »       }
56 66
57 »       public·bool·GetNavRight()67 »       public·bool·GetNavRight()
58 »       {68 »       {
195 B
Assembly-CSharp/KillAnimType.cs
    
Offset 3, 9 lines modifiedOffset 3, 10 lines modified
3 public·enum·KillAnimType3 public·enum·KillAnimType
4 {4 {
5 »       Stab,5 »       Stab,
6 »       Tongue,6 »       Tongue,
7 »       Shoot,7 »       Shoot,
8 »       Neck,8 »       Neck,
9 »       RHM,9 »       RHM,
 10 »       Werewolf_Slash,
10 »       None·=·999911 »       None·=·9999
11 }12 }
575 B
Assembly-CSharp/KillButton.cs
    
Offset 1, 12 lines modifiedOffset 1, 20 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 3
4 public·class·KillButton·:·ActionButton4 public·class·KillButton·:·ActionButton
5 {5 {
 6 »       public·PlayerControl·Target
 7 »       {
 8 »       »       get
 9 »       »       {
 10 »       »       »       return·this.currentTarget;
 11 »       »       }
 12 »       }
 13
6 »       public·override·void·DoClick()14 »       public·override·void·DoClick()
7 »       {15 »       {
8 »       »       if·(base.isActiveAndEnabled·&&·this.currentTarget·&&·!this.isCoolingDown·&&·!PlayerControl.LocalPlayer.Data.IsDead·&&·PlayerControl.LocalPlayer.CanMove)16 »       »       if·(base.isActiveAndEnabled·&&·this.currentTarget·&&·!this.isCoolingDown·&&·!PlayerControl.LocalPlayer.Data.IsDead·&&·PlayerControl.LocalPlayer.CanMove)
9 »       »       {17 »       »       {
10 »       »       »       PlayerControl.LocalPlayer.CmdCheckMurder(this.currentTarget);18 »       »       »       PlayerControl.LocalPlayer.CmdCheckMurder(this.currentTarget);
11 »       »       »       this.SetTarget(null);19 »       »       »       this.SetTarget(null);
12 »       »       }20 »       »       }
3.91 KB
Assembly-CSharp/KillOverlay.cs
    
Offset 19, 32 lines modifiedOffset 19, 18 lines modified
19 »       »       while·(this.showAll·!=·null·||·this.queue.Count·>·0)19 »       »       while·(this.showAll·!=·null·||·this.queue.Count·>·0)
20 »       »       {20 »       »       {
21 »       »       »       yield·return·null;21 »       »       »       yield·return·null;
22 »       »       }22 »       »       }
23 »       »       yield·break;23 »       »       yield·break;
24 »       }24 »       }
25 25
26 »       public·void·ShowKillAnimation(OverlayKillAnimation·killAnimation,·GameData.PlayerInfo·killer,·GameData.PlayerInfo·victim) 
27 »       { 
28 »       »       this.queue.Enqueue(delegate 
29 »       »       { 
30 »       »       »       OverlayKillAnimation·overlayKillAnimation·=·Object.Instantiate<OverlayKillAnimation>(killAnimation,·this.transform); 
31 »       »       »       overlayKillAnimation.Initialize(killer,·victim); 
32 »       »       »       overlayKillAnimation.gameObject.SetActive(false); 
33 »       »       »       return·this.CoShowOne(overlayKillAnimation); 
34 »       »       }); 
35 »       »       if·(this.showAll·==·null) 
36 »       »       { 
37 »       »       »       this.showAll·=·base.StartCoroutine(this.ShowAll()); 
38 »       »       } 
39 »       } 
40  
41 »       public·void·ShowKillAnimation(GameData.PlayerInfo·killer,·GameData.PlayerInfo·victim)26 »       public·void·ShowKillAnimation(NetworkedPlayerInfo·killer,·NetworkedPlayerInfo·victim)
42 »       {27 »       {
43 »       »       IEnumerable<OverlayKillAnimation>·enumerable·=·this.KillAnims;28 »       »       IEnumerable<OverlayKillAnimation>·enumerable·=·this.KillAnims;
 29 »       »       OverlayKillAnimation·overlayKillAnimation;
44 »       »       if·(killer.Object)30 »       »       if·(killer.Object)
45 »       »       {31 »       »       {
46 »       »       »       OverlayKillAnimation[]·killAnimations·=·killer.Object.MyPhysics.Animations.GetKillAnimations();32 »       »       »       OverlayKillAnimation[]·killAnimations·=·killer.Object.MyPhysics.Animations.GetKillAnimations();
47 »       »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek·&&·AprilFoolsMode.ShouldHorseAround())33 »       »       »       if·(GameOptionsManager.Instance.CurrentGameOptions.GameMode·==·GameModes.HideNSeek·&&·AprilFoolsMode.ShouldHorseAround())
48 »       »       »       {34 »       »       »       {
49 »       »       »       »       enumerable·=·this.HorseWrangleAnims;35 »       »       »       »       enumerable·=·this.HorseWrangleAnims;
50 »       »       »       }36 »       »       »       }
Offset 53, 28 lines modifiedOffset 39, 60 lines modified
53 »       »       »       »       enumerable·=·killAnimations;39 »       »       »       »       enumerable·=·killAnimations;
54 »       »       »       }40 »       »       »       }
55 »       »       »       else41 »       »       »       else
56 »       »       »       {42 »       »       »       {
57 »       »       »       »       SkinViewData·skin·=·ShipStatus.Instance.CosmeticsCache.GetSkin(killer.Object.CurrentOutfit.SkinId);43 »       »       »       »       SkinViewData·skin·=·ShipStatus.Instance.CosmeticsCache.GetSkin(killer.Object.CurrentOutfit.SkinId);
58 »       »       »       »       if·(skin·&&·skin.CustomKillAnimID·>·0)44 »       »       »       »       if·(skin·&&·skin.CustomKillAnimID·>·0)
59 »       »       »       »       {45 »       »       »       »       {
 46 »       »       »       »       »       if·(!string.IsNullOrEmpty(skin.HatID_KillAnim)·&&·skin.HatID_KillAnim·!=·killer.Object.CurrentOutfit.HatId)
 47 »       »       »       »       »       {
 48 »       »       »       »       »       »       overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>();
 49 »       »       »       »       »       »       this.ShowKillAnimation(overlayKillAnimation,·killer,·victim);
 50 »       »       »       »       »       »       return;
 51 »       »       »       »       »       }
 52 »       »       »       »       »       if·(!string.IsNullOrEmpty(skin.VisorID_KillAnim)·&&·skin.VisorID_KillAnim·!=·killer.Object.CurrentOutfit.VisorId)
 53 »       »       »       »       »       {
 54 »       »       »       »       »       »       overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>();
 55 »       »       »       »       »       »       this.ShowKillAnimation(overlayKillAnimation,·killer,·victim);
 56 »       »       »       »       »       »       return;
 57 »       »       »       »       »       }
60 »       »       »       »       »       enumerable·=·new·OverlayKillAnimation[]·{·this.CustomKillAnimations[skin.CustomKillAnimID·-·1]·};58 »       »       »       »       »       enumerable·=·new·OverlayKillAnimation[]·{·this.CustomKillAnimations[skin.CustomKillAnimID·-·1]·};
61 »       »       »       »       }59 »       »       »       »       }
62 »       »       »       }60 »       »       »       }
63 »       »       }61 »       »       }
64 »       »       OverlayKillAnimation·overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>();62 »       »       overlayKillAnimation·=·enumerable.Random<OverlayKillAnimation>();
65 »       »       this.ShowKillAnimation(overlayKillAnimation,·killer,·victim);63 »       »       this.ShowKillAnimation(overlayKillAnimation,·killer,·victim);
66 »       }64 »       }
67 65
 66 »       public·void·ShowKillAnimation(OverlayKillAnimation·killAnimation,·NetworkedPlayerInfo·killer,·NetworkedPlayerInfo·victim)
 67 »       {
 68 »       »       this.ShowKillAnimation(killAnimation,·new·KillOverlayInitData(killer,·victim));
 69 »       }
 70
 71 »       public·void·ShowKillAnimation(OverlayKillAnimation·killAnimation,·KillOverlayInitData·initData)
 72 »       {
 73 »       »       this.queue.Enqueue(delegate
 74 »       »       {
 75 »       »       »       OverlayKillAnimation·overlayKillAnimation·=·Object.Instantiate<OverlayKillAnimation>(killAnimation,·this.transform);
 76 »       »       »       overlayKillAnimation.Initialize(initData);
 77 »       »       »       overlayKillAnimation.gameObject.SetActive(false);
 78 »       »       »       return·this.CoShowOne(overlayKillAnimation);
 79 »       »       });
 80 »       »       if·(this.showAll·==·null)
 81 »       »       {
 82 »       »       »       this.showAll·=·base.StartCoroutine(this.ShowAll());
 83 »       »       }
 84 »       }
 85
68 »       public·void·ShowMeeting(MeetingCalledAnimation·prefab,·GameData.PlayerInfo·playerInfo)86 »       public·void·ShowMeeting(MeetingCalledAnimation·prefab,·NetworkedPlayerInfo.PlayerOutfit·playerOutfit)
69 »       {87 »       {
70 »       »       this.queue.Enqueue(delegate88 »       »       this.queue.Enqueue(delegate
71 »       »       {89 »       »       {
72 »       »       »       MeetingCalledAnimation·meetingCalledAnimation·=·Object.Instantiate<MeetingCalledAnimation>(prefab,·this.transform);90 »       »       »       MeetingCalledAnimation·meetingCalledAnimation·=·Object.Instantiate<MeetingCalledAnimation>(prefab,·this.transform);
73 »       »       »       meetingCalledAnimation.Initialize(playerInfo);91 »       »       »       meetingCalledAnimation.Initialize(playerOutfit);
74 »       »       »       meetingCalledAnimation.gameObject.SetActive(false);92 »       »       »       meetingCalledAnimation.gameObject.SetActive(false);
75 »       »       »       return·this.CoShowOne(meetingCalledAnimation);93 »       »       »       return·this.CoShowOne(meetingCalledAnimation);
76 »       »       });94 »       »       });
77 »       »       if·(this.showAll·==·null)95 »       »       if·(this.showAll·==·null)
78 »       »       {96 »       »       {
79 »       »       »       this.showAll·=·base.StartCoroutine(this.ShowAll());97 »       »       »       this.showAll·=·base.StartCoroutine(this.ShowAll());
80 »       »       }98 »       »       }
1.27 KB
Assembly-CSharp/Ladder.cs
    
Offset 43, 19 lines modifiedOffset 43, 19 lines modified
43 »       }43 »       }
44 44
45 »       private·void·Update()45 »       private·void·Update()
46 »       {46 »       {
47 »       »       this.CoolDown·=·Mathf.Max(this.CoolDown·-·Time.deltaTime,·0f);47 »       »       this.CoolDown·=·Mathf.Max(this.CoolDown·-·Time.deltaTime,·0f);
48 »       }48 »       }
49 49
50 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)50 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
51 »       {51 »       {
52 »       »       float·num·=·float.MaxValue;52 »       »       float·num·=·float.MaxValue;
53 »       »       PlayerControl·@object·=·pc.Object;53 »       »       PlayerControl·@object·=·pc.Object;
54 »       »       couldUse·=·!pc.IsDead·&&·@object.CanMove;54 »       »       couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·pc.Role.CanUse(this);
55 »       »       canUse·=·couldUse;55 »       »       canUse·=·couldUse;
56 »       »       if·(canUse)56 »       »       if·(canUse)
57 »       »       {57 »       »       {
58 »       »       »       Vector2·truePosition·=·@object.GetTruePosition();58 »       »       »       Vector2·truePosition·=·@object.GetTruePosition();
59 »       »       »       Vector3·position·=·base.transform.position;59 »       »       »       Vector3·position·=·base.transform.position;
60 »       »       »       num·=·Vector2.Distance(truePosition,·position);60 »       »       »       num·=·Vector2.Distance(truePosition,·position);
61 »       »       »       canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false);61 »       »       »       canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false);
Offset 72, 15 lines modifiedOffset 72, 15 lines modified
72 72
73 »       public·void·Use()73 »       public·void·Use()
74 »       {74 »       {
75 »       »       if·(this.IsCoolingDown())75 »       »       if·(this.IsCoolingDown())
76 »       »       {76 »       »       {
77 »       »       »       return;77 »       »       »       return;
78 »       »       }78 »       »       }
79 »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;79 »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
80 »       »       bool·flag;80 »       »       bool·flag;
81 »       »       bool·flag2;81 »       »       bool·flag2;
82 »       »       this.CanUse(data,·out·flag,·out·flag2);82 »       »       this.CanUse(data,·out·flag,·out·flag2);
83 »       »       if·(flag)83 »       »       if·(flag)
84 »       »       {84 »       »       {
85 »       »       »       PlayerControl.LocalPlayer.MyPhysics.RpcClimbLadder(this);85 »       »       »       PlayerControl.LocalPlayer.MyPhysics.RpcClimbLadder(this);
86 »       »       »       this.CoolDown·=·this.MaxCoolDown;86 »       »       »       this.CoolDown·=·this.MaxCoolDown;
467 B
Assembly-CSharp/LiftWeightsMinigame.cs
Ordering differences only
    
Offset 256, 16 lines modifiedOffset 256, 16 lines modified
256 256
257 »       [SerializeField]257 »       [SerializeField]
258 »       private·SpriteRenderer·buffButton;258 »       private·SpriteRenderer·buffButton;
259 259
260 »       [SerializeField]260 »       [SerializeField]
261 »       private·SpriteRenderer·hands;261 »       private·SpriteRenderer·hands;
262 262
263 »       [Header("Sounds")] 
264 »       [SerializeField]263 »       [SerializeField]
 264 »       [Header("Sounds")]
265 »       private·AudioClip·startLiftingSound;265 »       private·AudioClip·startLiftingSound;
266 266
267 »       [SerializeField]267 »       [SerializeField]
268 »       private·AudioClip·barfillSound;268 »       private·AudioClip·barfillSound;
269 269
270 »       [SerializeField]270 »       [SerializeField]
271 »       private·AudioClip·completeRepSound;271 »       private·AudioClip·completeRepSound;
440 B
Assembly-CSharp/LightSource.cs
Ordering differences only
    
Offset 361, 16 lines modifiedOffset 361, 16 lines modified
361 361
362 »       [SerializeField]362 »       [SerializeField]
363 »       private·Material·lightCutawayMaterial;363 »       private·Material·lightCutawayMaterial;
364 364
365 »       [SerializeField]365 »       [SerializeField]
366 »       private·Mesh·lightChildMesh;366 »       private·Mesh·lightChildMesh;
367 367
368 »       [SerializeField] 
369 »       [Space(10f)]368 »       [Space(10f)]
 369 »       [SerializeField]
370 »       private·LightSourceRendererType·rendererType;370 »       private·LightSourceRendererType·rendererType;
371 371
372 »       [SerializeField]372 »       [SerializeField]
373 »       private·bool·useFlashlight;373 »       private·bool·useFlashlight;
374 374
375 »       [Header("GPU·Settings")]375 »       [Header("GPU·Settings")]
376 »       [SerializeField]376 »       [SerializeField]
1.87 KB
Assembly-CSharp/LobbyBehaviour.cs
    
Offset 45, 36 lines modifiedOffset 45, 32 lines modified
45 »       private·IEnumerator·DelayPlayDropshipAmbience()45 »       private·IEnumerator·DelayPlayDropshipAmbience()
46 »       {46 »       {
47 »       »       SoundManager.Instance.StopAllSound();47 »       »       SoundManager.Instance.StopAllSound();
48 »       »       yield·return·new·WaitForSeconds(0.5f);48 »       »       yield·return·new·WaitForSeconds(0.5f);
49 »       »       AudioSource·audioSource·=·SoundManager.Instance.PlayNamedSound("DropShipAmb",·this.DropShipSound,·true,·SoundManager.Instance.AmbienceChannel);49 »       »       AudioSource·audioSource·=·SoundManager.Instance.PlayNamedSound("DropShipAmb",·this.DropShipSound,·true,·SoundManager.Instance.AmbienceChannel);
50 »       »       audioSource.loop·=·true;50 »       »       audioSource.loop·=·true;
51 »       »       audioSource.pitch·=·1.2f;51 »       »       audioSource.pitch·=·1.2f;
 52 »       »       SoundManager.Instance.CrossFadeSound("MapTheme",·this.MapTheme,·0.5f,·1.5f);
52 »       »       yield·break;53 »       »       yield·break;
53 »       }54 »       }
54 55
55 »       public·void·FixedUpdate()56 »       public·void·FixedUpdate()
56 »       {57 »       {
57 »       »       this.optionsTimer·+=·Time.fixedDeltaTime;58 »       »       this.optionsTimer·+=·Time.fixedDeltaTime;
58 »       »       if·(this.optionsTimer·<·0.25f)59 »       »       if·(this.optionsTimer·<·0.25f)
59 »       »       {60 »       »       {
60 »       »       »       return;61 »       »       »       return;
61 »       »       }62 »       »       }
62 »       »       this.optionsTimer·=·0f;63 »       »       this.optionsTimer·=·0f;
63 »       »       if·(GameOptionsManager.Instance.CurrentGameOptions·!=·null) 
64 »       »       { 
65 »       »       »       int·num·=·(GameData.Instance·?·GameData.Instance.PlayerCount·:·10); 
66 »       »       »       DestroyableSingleton<HudManager>.Instance.GameSettings.text·=·GameOptionsManager.Instance.CurrentGameOptions.ToHudString(num); 
67 »       »       »       DestroyableSingleton<HudManager>.Instance.GameSettings.gameObject.SetActive(true); 
68 »       »       } 
69 »       }64 »       }
70 65
71 »       public·override·void·OnDestroy()66 »       public·override·void·OnDestroy()
72 »       {67 »       {
73 »       »       SoundManager.Instance.StopNamedSound("DropShipAmb");68 »       »       SoundManager.Instance.StopNamedSound("DropShipAmb");
 69 »       »       SoundManager.Instance.CrossFadeSound("MapTheme",·null,·0.5f,·1.5f);
74 »       »       LobbyDebugCommands.RemoveCommands();70 »       »       LobbyDebugCommands.RemoveCommands();
75 »       »       base.OnDestroy();71 »       »       base.OnDestroy();
76 »       }72 »       }
77 73
78 »       public·override·void·HandleRpc(byte·callId,·MessageReader·reader)74 »       public·override·void·HandleRpc(byte·callId,·MessageReader·reader)
79 »       {75 »       {
80 »       »       if·(callId·==·60)76 »       »       if·(callId·==·60)
Offset 145, 14 lines modifiedOffset 141, 18 lines modified
145 141
146 »       public·AnimationClip·SpawnInClip;142 »       public·AnimationClip·SpawnInClip;
147 143
148 »       public·Vector2[]·SpawnPositions;144 »       public·Vector2[]·SpawnPositions;
149 145
150 »       public·AudioClip·DropShipSound;146 »       public·AudioClip·DropShipSound;
151 147
 148 »       public·AudioClip·MapTheme;
 149
 150 »       private·const·string·MAP_THEME_NAME·=·"MapTheme";
 151
152 »       public·SkeldShipRoom[]·AllRooms;152 »       public·SkeldShipRoom[]·AllRooms;
153 153
154 »       private·readonly·global::Logger·logger·=·new·global::Logger("LobbyBehaviour",·global::Logger.Level.Warning,·global::Logger.Category.Network);154 »       private·readonly·global::Logger·logger·=·new·global::Logger("LobbyBehaviour",·global::Logger.Level.Warning,·global::Logger.Category.Network);
155 155
156 »       private·float·lastFriendsCheckTime;156 »       private·float·lastFriendsCheckTime;
157 157
158 »       private·float·optionsTimer;158 »       private·float·optionsTimer;
1.46 KB
Assembly-CSharp/LobbyInviteBar.cs
    
Offset 1, 11 lines modifiedOffset 1, 9 lines modified
1 using·System;1 using·System;
2 using·System.Collections; 
3 using·Assets.InnerNet;2 using·Assets.InnerNet;
4 using·InnerNet; 
5 using·UnityEngine;3 using·UnityEngine;
6 4
7 public·class·LobbyInviteBar·:·FriendsListBar5 public·class·LobbyInviteBar·:·FriendsListBar
8 {6 {
9 »       public·void·SetUp(string·puid,·FriendsListUI·parentUI,·string·roomCode,·string·friendCode,·string·playerName)7 »       public·void·SetUp(string·puid,·FriendsListUI·parentUI,·string·roomCode,·string·friendCode,·string·playerName)
10 »       {8 »       {
11 »       »       this.SetUp(puid,·parentUI,·friendCode,·playerName);9 »       »       this.SetUp(puid,·parentUI,·friendCode,·playerName);
Offset 16, 30 lines modifiedOffset 14, 17 lines modified
16 »       public·void·PressAccept()14 »       public·void·PressAccept()
17 »       {15 »       {
18 »       »       if·(this.hasAccepted)16 »       »       if·(this.hasAccepted)
19 »       »       {17 »       »       {
20 »       »       »       return;18 »       »       »       return;
21 »       »       }19 »       »       }
22 »       »       this.hasAccepted·=·true;20 »       »       this.hasAccepted·=·true;
 21 »       »       DestroyableSingleton<FriendsListManager>.Instance.JoinGameViaFriendInvite(this.roomCode);
23 »       »       base.StartCoroutine(this.JoinGame()); 
24 »       } 
25  
26 »       private·IEnumerator·JoinGame() 
27 »       { 
28 »       »       DestroyableSingleton<FriendsListManager>.Instance.LoadScreen.enabled·=·true; 
29 »       »       if·(AmongUsClient.Instance·&&·AmongUsClient.Instance.AmClient) 
30 »       »       { 
31 »       »       »       AmongUsClient.Instance.ExitGame(DisconnectReasons.ExitGame); 
32 »       »       } 
33 »       »       int·num·=·GameCode.GameNameToInt(this.roomCode); 
34 »       »       yield·return·AmongUsClient.Instance.CoJoinOnlineGameFromCode(num); 
35 »       »       DestroyableSingleton<FriendsListManager>.Instance.LoadScreen.enabled·=·false; 
36 »       »       this.parentUI.Close(true);22 »       »       this.parentUI.Close(true);
37 »       »       this.DenyLobbyInvite();23 »       »       this.DenyLobbyInvite();
38 »       »       yield·break; 
39 »       }24 »       }
40 25
41 »       public·void·DenyLobbyInvite()26 »       public·void·DenyLobbyInvite()
42 »       {27 »       {
43 »       »       DestroyableSingleton<FriendsListManager>.Instance.DenyLobbyInvite(this.puid,·delegate(ResponseState·cb,·Response<ResponseFriendsListRequest>·response)28 »       »       DestroyableSingleton<FriendsListManager>.Instance.DenyLobbyInvite(this.puid,·delegate(ResponseState·cb,·Response<ResponseFriendsListRequest>·response)
44 »       »       {29 »       »       {
45 »       »       »       if·(cb·==·ResponseState.Success)30 »       »       »       if·(cb·==·ResponseState.Success)
2.73 KB
Assembly-CSharp/LobbyTimerExtensionUI.cs
    
Offset 2, 16 lines modifiedOffset 2, 16 lines modified
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 public·class·LobbyTimerExtensionUI·:·MonoBehaviour4 public·class·LobbyTimerExtensionUI·:·MonoBehaviour
5 {5 {
6 »       private·void·Awake()6 »       private·void·Awake()
7 »       {7 »       {
8 »       »       string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringUnit,·Array.Empty<object>());8 »       »       string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringUnit,·Array.Empty<object>());
9 »       »       string·text·=·"<color=red>{0}"·+·@string·+·"</color>";9 »       »       string·text·=·"{0}"·+·@string;
10 »       »       this.timerTextTemplate·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·});10 »       »       this.timerTextTemplate·=·"<font-weight=800>"·+·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·});
11 »       »       string·text2·=·"<color=green>{0}"·+·@string·+·"</color>";11 »       »       string·text2·=·"<color=green>{0}"·+·@string·+·"</color>";
12 »       »       this.popupTitleText·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg,·new·object[]·{·text2·});12 »       »       this.popupTitleText·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg,·new·object[]·{·text2·});
13 »       »       this.popupBodyTextTemplate·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·});13 »       »       this.popupBodyTextTemplate·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringMsg2,·new·object[]·{·text·});
14 »       »       this.popup.button1Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringNo,·Array.Empty<object>()),·true);14 »       »       this.popup.button1Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringNo,·Array.Empty<object>()),·true);
15 »       »       this.popup.button2Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringOk,·Array.Empty<object>()),·true);15 »       »       this.popup.button2Text.SetText(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyTimerExpiringOk,·Array.Empty<object>()),·true);
16 »       »       this.popup.button1.OnClick.AddListener(delegate16 »       »       this.popup.button1.OnClick.AddListener(delegate
17 »       »       {17 »       »       {
Offset 32, 38 lines modifiedOffset 32, 42 lines modified
32 »       {32 »       {
33 »       »       this.HideLobbyTimer();33 »       »       this.HideLobbyTimer();
34 »       »       this.popup.Close();34 »       »       this.popup.Close();
35 »       }35 »       }
36 36
37 »       public·void·ShowLobbyTimer(int·timeRemainingSeconds)37 »       public·void·ShowLobbyTimer(int·timeRemainingSeconds)
38 »       {38 »       {
 39 »       »       SoundManager.Instance.PlaySound(this.lobbyTimerPopUpSound,·false,·1f,·null);
39 »       »       this.timerText.SetTimer((float)timeRemainingSeconds,·this.timerTextTemplate);40 »       »       this.timerText.SetTimer((float)timeRemainingSeconds,·this.timerTextTemplate);
40 »       »       this.timerText.gameObject.SetActive(true);41 »       »       this.timerText.transform.parent.gameObject.SetActive(true);
41 »       }42 »       }
42 43
43 »       public·void·ShowLobbyTimerPopup(int·timeRemainingSeconds,·int·timeGrantedSeconds)44 »       public·void·ShowLobbyTimerPopup(int·timeRemainingSeconds,·int·timeGrantedSeconds)
44 »       {45 »       {
45 »       »       this.popupTimerText.SetTimer((float)timeRemainingSeconds,·this.popupBodyTextTemplate);46 »       »       this.popupTimerText.SetTimer((float)timeRemainingSeconds,·this.popupBodyTextTemplate);
46 »       »       this.popup.titleTexxt.SetText(string.Format(this.popupTitleText,·timeGrantedSeconds),·true);47 »       »       this.popup.titleTexxt.SetText(string.Format(this.popupTitleText,·timeGrantedSeconds),·true);
47 »       »       this.popup.gameObject.SetActive(true);48 »       »       this.popup.gameObject.SetActive(true);
48 »       }49 »       }
49 50
50 »       private·void·HideLobbyTimer()51 »       private·void·HideLobbyTimer()
51 »       {52 »       {
52 »       »       this.timerText.gameObject.SetActive(false);53 »       »       this.timerText.transform.parent.gameObject.SetActive(false);
53 »       }54 »       }
54 55
55 »       [SerializeField]56 »       [SerializeField]
56 »       private·TimerTextTMP·timerText;57 »       private·TimerTextTMP·timerText;
57 58
58 »       [SerializeField]59 »       [SerializeField]
59 »       private·InfoTextBox·popup;60 »       private·InfoTextBox·popup;
60 61
61 »       [SerializeField]62 »       [SerializeField]
62 »       private·TimerTextTMP·popupTimerText;63 »       private·TimerTextTMP·popupTimerText;
63 64
 65 »       [SerializeField]
 66 »       private·AudioClip·lobbyTimerPopUpSound;
 67
64 »       private·string·timerTextTemplate;68 »       private·string·timerTextTemplate;
65 69
66 »       private·string·popupTitleText;70 »       private·string·popupTitleText;
67 71
68 »       private·string·popupBodyTextTemplate;72 »       private·string·popupBodyTextTemplate;
69 }73 }
1.72 KB
Assembly-CSharp/LogEntryBubble.cs
    
Offset 3, 15 lines modifiedOffset 3, 15 lines modified
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·LogEntryBubble·:·PoolableBehavior6 public·class·LogEntryBubble·:·PoolableBehavior
7 {7 {
8 »       public·void·DecorateLog(SecurityLogBehaviour.SecurityLogEntry·entry,·Sprite·backgroundSprite)8 »       public·void·DecorateLog(SecurityLogBehaviour.SecurityLogEntry·entry,·Sprite·backgroundSprite)
9 »       {9 »       {
10 »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(entry.PlayerId);10 »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(entry.PlayerId);
11 »       »       if·(playerById·==·null)11 »       »       if·(playerById·==·null)
12 »       »       {12 »       »       {
13 »       »       »       Debug.LogError(string.Format("Couldn't·find·player·{0}·for·log",·entry.PlayerId));13 »       »       »       Debug.LogError(string.Format("Couldn't·find·player·{0}·for·log",·entry.PlayerId));
14 »       »       »       return;14 »       »       »       return;
15 »       »       }15 »       »       }
16 »       »       this.SetCosmetics(playerById);16 »       »       this.SetCosmetics(playerById);
17 »       »       this.SetText(entry,·playerById);17 »       »       this.SetText(entry,·playerById);
Offset 26, 21 lines modifiedOffset 26, 21 lines modified
26 »       }26 »       }
27 27
28 »       private·void·SetBackground(Sprite·backgroundSprite)28 »       private·void·SetBackground(Sprite·backgroundSprite)
29 »       {29 »       {
30 »       »       this.background.sprite·=·backgroundSprite;30 »       »       this.background.sprite·=·backgroundSprite;
31 »       }31 »       }
32 32
33 »       private·void·SetCosmetics(GameData.PlayerInfo·playerData)33 »       private·void·SetCosmetics(NetworkedPlayerInfo·playerData)
34 »       {34 »       {
35 »       »       this.player.UpdateFromPlayerData(playerData,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null,·true);35 »       »       this.player.UpdateFromPlayerData(playerData,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ScrollingUI,·false,·null,·true);
36 »       »       this.player.ToggleName(false);36 »       »       this.player.ToggleName(false);
37 »       }37 »       }
38 38
39 »       private·void·SetText(SecurityLogBehaviour.SecurityLogEntry·entry,·GameData.PlayerInfo·playerData)39 »       private·void·SetText(SecurityLogBehaviour.SecurityLogEntry·entry,·NetworkedPlayerInfo·playerData)
40 »       {40 »       {
41 »       »       string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LogNorth·+·(int)entry.Location,·Array.Empty<object>());41 »       »       string·@string·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LogNorth·+·(int)entry.Location,·Array.Empty<object>());
42 »       »       int·colorId·=·playerData.DefaultOutfit.ColorId;42 »       »       int·colorId·=·playerData.DefaultOutfit.ColorId;
43 »       »       string·text·=·this.text.text;43 »       »       string·text·=·this.text.text;
44 »       »       if·(DataManager.Settings.Accessibility.ColorBlindMode)44 »       »       if·(DataManager.Settings.Accessibility.ColorBlindMode)
45 »       »       {45 »       »       {
46 »       »       »       string·text2·=·DestroyableSingleton<TranslationController>.Instance.GetString(Palette.ColorNames[colorId],·Array.Empty<object>()).ToLower();46 »       »       »       string·text2·=·DestroyableSingleton<TranslationController>.Instance.GetString(Palette.ColorNames[colorId],·Array.Empty<object>()).ToLower();
1.29 KB
Assembly-CSharp/LogicGameFlow.cs
    
Offset 16, 35 lines modifiedOffset 16, 35 lines modified
16 »       protected·ValueTuple<int,·int,·int>·GetPlayerCounts()16 »       protected·ValueTuple<int,·int,·int>·GetPlayerCounts()
17 »       {17 »       {
18 »       »       int·num·=·0;18 »       »       int·num·=·0;
19 »       »       int·num2·=·0;19 »       »       int·num2·=·0;
20 »       »       int·num3·=·0;20 »       »       int·num3·=·0;
21 »       »       for·(int·i·=·0;·i·<·GameData.Instance.PlayerCount;·i++)21 »       »       for·(int·i·=·0;·i·<·GameData.Instance.PlayerCount;·i++)
22 »       »       {22 »       »       {
23 »       »       »       GameData.PlayerInfo·playerInfo·=·GameData.Instance.AllPlayers[i];23 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AllPlayers[i];
24 »       »       »       if·(playerInfo·!=·null·&&·!playerInfo.Disconnected·&&·!(playerInfo.Role·==·null))24 »       »       »       if·(!(networkedPlayerInfo·==·null)·&&·!networkedPlayerInfo.Disconnected·&&·!(networkedPlayerInfo.Role·==·null))
25 »       »       »       {25 »       »       »       {
26 »       »       »       »       if·(playerInfo.Role.IsImpostor)26 »       »       »       »       if·(networkedPlayerInfo.Role.IsImpostor)
27 »       »       »       »       {27 »       »       »       »       {
28 »       »       »       »       »       num3++;28 »       »       »       »       »       num3++;
29 »       »       »       »       }29 »       »       »       »       }
30 »       »       »       »       if·(!playerInfo.IsDead)30 »       »       »       »       if·(!networkedPlayerInfo.IsDead)
31 »       »       »       »       {31 »       »       »       »       {
32 »       »       »       »       »       if·(playerInfo.Role.IsImpostor)32 »       »       »       »       »       if·(networkedPlayerInfo.Role.IsImpostor)
33 »       »       »       »       »       {33 »       »       »       »       »       {
34 »       »       »       »       »       »       num2++;34 »       »       »       »       »       »       num2++;
35 »       »       »       »       »       }35 »       »       »       »       »       }
36 »       »       »       »       »       else36 »       »       »       »       »       else
37 »       »       »       »       »       {37 »       »       »       »       »       {
38 »       »       »       »       »       »       num++;38 »       »       »       »       »       »       num++;
39 »       »       »       »       »       }39 »       »       »       »       »       }
40 »       »       »       »       }40 »       »       »       »       }
41 »       »       »       »       else41 »       »       »       »       else
42 »       »       »       »       {42 »       »       »       »       {
43 »       »       »       »       »       ImpostorGhostRole·impostorGhostRole·=·playerInfo.Role·as·ImpostorGhostRole;43 »       »       »       »       »       ImpostorGhostRole·impostorGhostRole·=·networkedPlayerInfo.Role·as·ImpostorGhostRole;
44 »       »       »       »       »       if·(impostorGhostRole·!=·null·&&·impostorGhostRole.WasManuallyPicked)44 »       »       »       »       »       if·(impostorGhostRole·!=·null·&&·impostorGhostRole.WasManuallyPicked)
45 »       »       »       »       »       {45 »       »       »       »       »       {
46 »       »       »       »       »       »       num2++;46 »       »       »       »       »       »       num2++;
47 »       »       »       »       »       }47 »       »       »       »       »       }
48 »       »       »       »       }48 »       »       »       »       }
49 »       »       »       }49 »       »       »       }
50 »       »       }50 »       »       }
1.01 KB
Assembly-CSharp/LogicGameFlowHnS.cs
    
Offset 36, 15 lines modifiedOffset 36, 15 lines modified
36 »       »       this.hideAndSeekManager·=·manager;36 »       »       this.hideAndSeekManager·=·manager;
37 »       »       this.timerBarPrefab·=·timerBarPrefab;37 »       »       this.timerBarPrefab·=·timerBarPrefab;
38 »       }38 »       }
39 39
40 »       public·bool·SeekerAdminMapEnabled(PlayerControl·player)40 »       public·bool·SeekerAdminMapEnabled(PlayerControl·player)
41 »       {41 »       {
42 »       »       int·item·=·base.GetPlayerCounts().Item1;42 »       »       int·item·=·base.GetPlayerCounts().Item1;
43 »       »       return·!player.inVent·&&·player.Data·!=·null·&&·!(player.Data.Role·==·null)·&&·((!player.inVent·&&·player.Data.Role.IsImpostor·&&·this.IsFinalCountdown·&&·this.hideAndSeekManager.LogicOptionsHnS.GetSeekerFinalMap())·||·(player.Data.Role.IsImpostor·&&·item·<=·(GameData.Instance.PlayerCount·-·1)·/·3));43 »       »       return·!player.inVent·&&·!(player.Data·==·null)·&&·!(player.Data.Role·==·null)·&&·((!player.inVent·&&·player.Data.Role.IsImpostor·&&·this.IsFinalCountdown·&&·this.hideAndSeekManager.LogicOptionsHnS.GetSeekerFinalMap())·||·(player.Data.Role.IsImpostor·&&·item·<=·(GameData.Instance.PlayerCount·-·1)·/·3));
44 »       }44 »       }
45 45
46 »       public·void·OnTaskComplete(float·timeDeduction)46 »       public·void·OnTaskComplete(float·timeDeduction)
47 »       {47 »       {
48 »       »       if·(this.timerBar·!=·null)48 »       »       if·(this.timerBar·!=·null)
49 »       »       {49 »       »       {
50 »       »       »       this.timerBar.TaskComplete();50 »       »       »       this.timerBar.TaskComplete();
539 B
Assembly-CSharp/LogicGameFlowNormal.cs
    
Offset 99, 15 lines modifiedOffset 99, 15 lines modified
99 »       »       »       }99 »       »       »       }
100 »       »       }100 »       »       }
101 »       »       else·if·(item·<=·item2)101 »       »       else·if·(item·<=·item2)
102 »       »       {102 »       »       {
103 »       »       »       if·(!DestroyableSingleton<TutorialManager>.InstanceExists)103 »       »       »       if·(!DestroyableSingleton<TutorialManager>.InstanceExists)
104 »       »       »       {104 »       »       »       {
105 »       »       »       »       GameOverReason·gameOverReason2;105 »       »       »       »       GameOverReason·gameOverReason2;
106 »       »       »       »       switch·(TempData.LastDeathReason)106 »       »       »       »       switch·(GameData.LastDeathReason)
107 »       »       »       »       {107 »       »       »       »       {
108 »       »       »       »       case·DeathReason.Exile:108 »       »       »       »       case·DeathReason.Exile:
109 »       »       »       »       »       gameOverReason2·=·GameOverReason.ImpostorByVote;109 »       »       »       »       »       gameOverReason2·=·GameOverReason.ImpostorByVote;
110 »       »       »       »       »       break;110 »       »       »       »       »       break;
111 »       »       »       »       case·DeathReason.Kill:111 »       »       »       »       case·DeathReason.Kill:
112 »       »       »       »       »       gameOverReason2·=·GameOverReason.ImpostorByKill;112 »       »       »       »       »       gameOverReason2·=·GameOverReason.ImpostorByKill;
113 »       »       »       »       »       break;113 »       »       »       »       »       break;
1.41 KB
Assembly-CSharp/LogicHnSDangerLevel.cs
    
Offset 18, 15 lines modifiedOffset 18, 15 lines modified
18 »       »       {18 »       »       {
19 »       »       »       this.dangerMeter·=·DestroyableSingleton<HudManager>.Instance.DangerMeter;19 »       »       »       this.dangerMeter·=·DestroyableSingleton<HudManager>.Instance.DangerMeter;
20 »       »       »       this.dangerMeter.gameObject.SetActive(true);20 »       »       »       this.dangerMeter.gameObject.SetActive(true);
21 »       »       }21 »       »       }
22 »       »       this.impostors·=·new·List<PlayerControl>();22 »       »       this.impostors·=·new·List<PlayerControl>();
23 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)23 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
24 »       »       {24 »       »       {
25 »       »       »       GameData.PlayerInfo·data·=·playerControl.Data;25 »       »       »       NetworkedPlayerInfo·data·=·playerControl.Data;
26 »       »       »       if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·playerControl.Data.Role.IsImpostor)26 »       »       »       if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·playerControl.Data.Role.IsImpostor)
27 »       »       »       {27 »       »       »       {
28 »       »       »       »       this.impostors.Add(playerControl);28 »       »       »       »       this.impostors.Add(playerControl);
29 »       »       »       }29 »       »       »       }
30 »       »       }30 »       »       }
31 »       »       this.scaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase;31 »       »       this.scaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase;
32 »       »       this.veryScaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetVeryScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase;32 »       »       this.veryScaryMusicDistance·=·this.hnsManager.LogicOptionsHnS.GetVeryScaryMusicDistance()·*·this.hnsManager.LogicOptionsHnS.PlayerSpeedBase;
Offset 106, 15 lines modifiedOffset 106, 16 lines modified
106 »       »       }106 »       »       }
107 »       »       this.UpdateDangerMeter();107 »       »       this.UpdateDangerMeter();
108 »       »       this.UpdateDangerMusic();108 »       »       this.UpdateDangerMusic();
109 »       }109 »       }
110 110
111 »       private·void·UpdateDangerMusic()111 »       private·void·UpdateDangerMusic()
112 »       {112 »       {
113 »       »       if·(PlayerControl.LocalPlayer.Data.IsDead)113 »       »       PlayerControl·localPlayer·=·PlayerControl.LocalPlayer;
 114 »       »       if·(localPlayer·!=·null·&&·localPlayer.Data·!=·null·&&·localPlayer.Data.IsDead)
114 »       »       {115 »       »       {
115 »       »       »       this.hnsManager.LogicMusic.SetTaskState(false);116 »       »       »       this.hnsManager.LogicMusic.SetTaskState(false);
116 »       »       »       this.hnsManager.LogicMusic.ResetMusic();117 »       »       »       this.hnsManager.LogicMusic.ResetMusic();
117 »       »       »       return;118 »       »       »       return;
118 »       »       }119 »       »       }
119 »       »       this.hnsManager.LogicMusic.SetMusicValues(this.dangerLevel1,·this.dangerLevel2);120 »       »       this.hnsManager.LogicMusic.SetMusicValues(this.dangerLevel1,·this.dangerLevel2);
120 »       }121 »       }
597 B
Assembly-CSharp/LogicHnSMusic.cs
    
Offset 126, 15 lines modifiedOffset 126, 15 lines modified
126 »       public·void·SetMusicCrossfadeSpeed(float·lerpSpeed)126 »       public·void·SetMusicCrossfadeSpeed(float·lerpSpeed)
127 »       {127 »       {
128 »       »       this.musicLerpSpeed·=·lerpSpeed;128 »       »       this.musicLerpSpeed·=·lerpSpeed;
129 »       }129 »       }
130 130
131 »       public·void·SetMusicValues(float·dangerLevel1,·float·dangerLevel2)131 »       public·void·SetMusicValues(float·dangerLevel1,·float·dangerLevel2)
132 »       {132 »       {
133 »       »       if·(PlayerControl.LocalPlayer.Data.Role.IsImpostor)133 »       »       if·(PlayerControl.LocalPlayer·!=·null·&&·PlayerControl.LocalPlayer.Data.Role.IsImpostor)
134 »       »       {134 »       »       {
135 »       »       »       return;135 »       »       »       return;
136 »       »       }136 »       »       }
137 »       »       if·(this.normalSource·==·null·||·this.taskSource·==·null·||·this.dangerLevel1Source·==·null·||·this.dangerLevel2Source·==·null)137 »       »       if·(this.normalSource·==·null·||·this.taskSource·==·null·||·this.dangerLevel1Source·==·null·||·this.dangerLevel2Source·==·null)
138 »       »       {138 »       »       {
139 »       »       »       return;139 »       »       »       return;
140 »       »       }140 »       »       }
1.8 KB
Assembly-CSharp/LogicOptions.cs
    
Offset 149, 14 lines modifiedOffset 149, 80 lines modified
149 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.ScientistBatteryCharge,·out·num))149 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.ScientistBatteryCharge,·out·num))
150 »       »       {150 »       »       {
151 »       »       »       return·1f;151 »       »       »       return·1f;
152 »       »       }152 »       »       }
153 »       »       return·num;153 »       »       return·num;
154 »       }154 »       }
155 155
 156 »       public·virtual·float·GetPhantomCooldown()
 157 »       {
 158 »       »       float·num;
 159 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.PhantomCooldown,·out·num))
 160 »       »       {
 161 »       »       »       return·1f;
 162 »       »       }
 163 »       »       return·num;
 164 »       }
 165
 166 »       public·virtual·float·GetPhantomDuration()
 167 »       {
 168 »       »       float·num;
 169 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.PhantomDuration,·out·num))
 170 »       »       {
 171 »       »       »       return·1f;
 172 »       »       }
 173 »       »       return·num;
 174 »       }
 175
 176 »       public·virtual·float·GetTrackerCooldown()
 177 »       {
 178 »       »       float·num;
 179 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.TrackerCooldown,·out·num))
 180 »       »       {
 181 »       »       »       return·1f;
 182 »       »       }
 183 »       »       return·num;
 184 »       }
 185
 186 »       public·virtual·float·GetTrackerDuration()
 187 »       {
 188 »       »       float·num;
 189 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.TrackerDuration,·out·num))
 190 »       »       {
 191 »       »       »       return·1f;
 192 »       »       }
 193 »       »       return·num;
 194 »       }
 195
 196 »       public·virtual·float·GetTrackerDelay()
 197 »       {
 198 »       »       float·num;
 199 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.TrackerDelay,·out·num))
 200 »       »       {
 201 »       »       »       return·1f;
 202 »       »       }
 203 »       »       return·num;
 204 »       }
 205
 206 »       public·virtual·bool·GetNoisemakerImpostorAlert()
 207 »       {
 208 »       »       bool·flag;
 209 »       »       return·this.currentGameOptions.TryGetBool(BoolOptionNames.NoisemakerImpostorAlert,·out·flag)·&&·flag;
 210 »       }
 211
 212 »       public·virtual·float·GetNoisemakerAlertDuration()
 213 »       {
 214 »       »       float·num;
 215 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.NoisemakerAlertDuration,·out·num))
 216 »       »       {
 217 »       »       »       return·1f;
 218 »       »       }
 219 »       »       return·num;
 220 »       }
 221
156 »       public·virtual·float·GetKillCooldown()222 »       public·virtual·float·GetKillCooldown()
157 »       {223 »       {
158 »       »       float·num;224 »       »       float·num;
159 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.KillCooldown,·out·num))225 »       »       if·(!this.currentGameOptions.TryGetFloat(FloatOptionNames.KillCooldown,·out·num))
160 »       »       {226 »       »       {
161 »       »       »       return·1f;227 »       »       »       return·1f;
162 »       »       }228 »       »       }
2.28 KB
Assembly-CSharp/LogicOptionsHnS.cs
    
Offset 7, 15 lines modifiedOffset 7, 15 lines modified
7 {7 {
8 »       public·LogicOptionsHnS(HideAndSeekManager·manager)8 »       public·LogicOptionsHnS(HideAndSeekManager·manager)
9 »       »       :·base(manager)9 »       »       :·base(manager)
10 »       {10 »       {
11 »       »       this.HnSManager·=·manager;11 »       »       this.HnSManager·=·manager;
12 »       »       if·(AmongUsClient.Instance.AmHost)12 »       »       if·(AmongUsClient.Instance.AmHost)
13 »       »       {13 »       »       {
14 »       »       »       this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·HideNSeekGameOptionsV07;14 »       »       »       this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·HideNSeekGameOptionsV08;
15 »       »       »       this.GameOptions.ImpostorPlayerID·=·-1;15 »       »       »       this.GameOptions.ImpostorPlayerID·=·-1;
16 »       »       }16 »       »       }
17 »       }17 »       }
18 18
19 »       public·float·PlayerSpeedBase19 »       public·float·PlayerSpeedBase
20 »       {20 »       {
21 »       »       get21 »       »       get
Offset 44, 15 lines modifiedOffset 44, 15 lines modified
44 »       »       »       num·*=·this.GameOptions.SeekerFinalSpeed;44 »       »       »       num·*=·this.GameOptions.SeekerFinalSpeed;
45 »       »       }45 »       »       }
46 »       »       return·num;46 »       »       return·num;
47 »       }47 »       }
48 48
49 »       public·override·float·GetKillDistance()49 »       public·override·float·GetKillDistance()
50 »       {50 »       {
51 »       »       return·HideNSeekGameOptionsV07.KillDistances[Mathf.Clamp(this.GameOptions.KillDistance,·0,·HideNSeekGameOptionsV07.KillDistances.Length·-·1)];51 »       »       return·HideNSeekGameOptionsV08.KillDistances[Mathf.Clamp(this.GameOptions.KillDistance,·0,·HideNSeekGameOptionsV08.KillDistances.Length·-·1)];
52 »       }52 »       }
53 53
54 »       public·override·float·GetEngineerCooldown()54 »       public·override·float·GetEngineerCooldown()
55 »       {55 »       {
56 »       »       return·this.GetCrewmateVentCooldown();56 »       »       return·this.GetCrewmateVentCooldown();
57 »       }57 »       }
58 58
Offset 127, 17 lines modifiedOffset 127, 17 lines modified
127 »       }127 »       }
128 128
129 »       public·bool·HasImpostorPlayerID()129 »       public·bool·HasImpostorPlayerID()
130 »       {130 »       {
131 »       »       return·this.GameOptions.ImpostorPlayerID·>·-1;131 »       »       return·this.GameOptions.ImpostorPlayerID·>·-1;
132 »       }132 »       }
133 133
134 »       public·bool·ValidateImpostorPlayerID(List<GameData.PlayerInfo>·players)134 »       public·bool·ValidateImpostorPlayerID(List<NetworkedPlayerInfo>·players)
135 »       {135 »       {
136 »       »       return·this.HasImpostorPlayerID()·&&·players.Find((GameData.PlayerInfo·p)·=>·(int)p.PlayerId·==·this.ImpostorPlayerID())·!=·null;136 »       »       return·this.HasImpostorPlayerID()·&&·players.Find((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.ImpostorPlayerID())·!=·null;
137 »       }137 »       }
138 138
139 »       public·bool·GetSeekerPings()139 »       public·bool·GetSeekerPings()
140 »       {140 »       {
141 »       »       return·this.GameOptions.SeekerPings;141 »       »       return·this.GameOptions.SeekerPings;
142 »       }142 »       }
143 143
Offset 203, 21 lines modifiedOffset 203, 21 lines modified
203 »       »       {203 »       »       {
204 »       »       »       return·this.GameOptions;204 »       »       »       return·this.GameOptions;
205 »       »       }205 »       »       }
206 »       }206 »       }
207 207
208 »       protected·override·void·SetGameOptions(IGameOptions·newOptions)208 »       protected·override·void·SetGameOptions(IGameOptions·newOptions)
209 »       {209 »       {
210 »       »       this.GameOptions·=·newOptions·as·HideNSeekGameOptionsV07;210 »       »       this.GameOptions·=·newOptions·as·HideNSeekGameOptionsV08;
211 »       »       base.SetDirty();211 »       »       base.SetDirty();
212 »       }212 »       }
213 213
214 »       private·const·float·CommonShortTaskTime·=·5f;214 »       private·const·float·CommonShortTaskTime·=·5f;
215 215
216 »       private·const·float·LongTaskTime·=·10f;216 »       private·const·float·LongTaskTime·=·10f;
217 217
218 »       private·const·float·TaskTimePlayerDelta·=·1f;218 »       private·const·float·TaskTimePlayerDelta·=·1f;
219 219
220 »       private·HideNSeekGameOptionsV07·GameOptions;220 »       private·HideNSeekGameOptionsV08·GameOptions;
221 221
222 »       private·HideAndSeekManager·HnSManager;222 »       private·HideAndSeekManager·HnSManager;
223 }223 }
942 B
Assembly-CSharp/LogicOptionsNormal.cs
    
Offset 4, 15 lines modifiedOffset 4, 15 lines modified
4 public·class·LogicOptionsNormal·:·LogicOptions4 public·class·LogicOptionsNormal·:·LogicOptions
5 {5 {
6 »       public·LogicOptionsNormal(GameManager·manager)6 »       public·LogicOptionsNormal(GameManager·manager)
7 »       »       :·base(manager)7 »       »       :·base(manager)
8 »       {8 »       {
9 »       »       if·(AmongUsClient.Instance.AmHost)9 »       »       if·(AmongUsClient.Instance.AmHost)
10 »       »       {10 »       »       {
11 »       »       »       this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·NormalGameOptionsV07;11 »       »       »       this.GameOptions·=·GameOptionsManager.Instance.CurrentGameOptions·as·NormalGameOptionsV08;
12 »       »       }12 »       »       }
13 »       }13 »       }
14 14
15 »       public·int·GetDiscussionTime()15 »       public·int·GetDiscussionTime()
16 »       {16 »       {
17 »       »       return·this.GameOptions.DiscussionTime;17 »       »       return·this.GameOptions.DiscussionTime;
18 »       }18 »       }
Offset 74, 13 lines modifiedOffset 74, 13 lines modified
74 »       »       {74 »       »       {
75 »       »       »       return·this.GameOptions;75 »       »       »       return·this.GameOptions;
76 »       »       }76 »       »       }
77 »       }77 »       }
78 78
79 »       protected·override·void·SetGameOptions(IGameOptions·newOptions)79 »       protected·override·void·SetGameOptions(IGameOptions·newOptions)
80 »       {80 »       {
81 »       »       this.GameOptions·=·newOptions·as·NormalGameOptionsV07;81 »       »       this.GameOptions·=·newOptions·as·NormalGameOptionsV08;
82 »       »       base.SetDirty();82 »       »       base.SetDirty();
83 »       }83 »       }
84 84
85 »       private·NormalGameOptionsV07·GameOptions;85 »       private·NormalGameOptionsV08·GameOptions;
86 }86 }
643 B
Assembly-CSharp/LogicRoleSelection.cs
    
Offset 5, 11 lines modifiedOffset 5, 11 lines modified
5 public·abstract·class·LogicRoleSelection·:·GameLogicComponent5 public·abstract·class·LogicRoleSelection·:·GameLogicComponent
6 {6 {
7 »       public·LogicRoleSelection(GameManager·manager)7 »       public·LogicRoleSelection(GameManager·manager)
8 »       »       :·base(manager)8 »       »       :·base(manager)
9 »       {9 »       {
10 »       }10 »       }
11 11
12 »       public·abstract·void·AssignRolesForTeam(List<GameData.PlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole);12 »       public·abstract·void·AssignRolesForTeam(List<NetworkedPlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole);
13 13
14 »       public·abstract·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole);14 »       public·abstract·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole);
15 }15 }
2.81 KB
Assembly-CSharp/LogicRoleSelectionHnS.cs
    
Offset 32, 49 lines modifiedOffset 32, 49 lines modified
32 »       »       return·false;32 »       »       return·false;
33 »       }33 »       }
34 34
35 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)35 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)
36 »       {36 »       {
37 »       }37 »       }
38 38
39 »       public·override·void·AssignRolesForTeam(List<GameData.PlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole)39 »       public·override·void·AssignRolesForTeam(List<NetworkedPlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole)
40 »       {40 »       {
41 »       »       if·(team·==·RoleTeamTypes.Crewmate)41 »       »       if·(team·==·RoleTeamTypes.Crewmate)
42 »       »       {42 »       »       {
43 »       »       »       players.ForEach(delegate(GameData.PlayerInfo·player)43 »       »       »       players.ForEach(delegate(NetworkedPlayerInfo·player)
44 »       »       »       {44 »       »       »       {
45 »       »       »       »       player.Object.RpcSetRole(RoleTypes.Engineer);45 »       »       »       »       player.Object.RpcSetRole(RoleTypes.Engineer,·false);
46 »       »       »       });46 »       »       »       });
47 »       »       »       return;47 »       »       »       return;
48 »       »       }48 »       »       }
49 »       »       bool·flag·=·!AmongUsClient.Instance.IsGamePublic;49 »       »       bool·flag·=·!AmongUsClient.Instance.IsGamePublic;
50 »       »       if·(this.hnsManager.LogicOptionsHnS.HasImpostorPlayerID()·&&·this.hnsManager.LogicOptionsHnS.ValidateImpostorPlayerID(players)·&&·flag)50 »       »       if·(this.hnsManager.LogicOptionsHnS.HasImpostorPlayerID()·&&·this.hnsManager.LogicOptionsHnS.ValidateImpostorPlayerID(players)·&&·flag)
51 »       »       {51 »       »       {
52 »       »       »       GameData.PlayerInfo·playerInfo·=·players.Find((GameData.PlayerInfo·p)·=>·(int)p.PlayerId·==·this.hnsManager.LogicOptionsHnS.ImpostorPlayerID());52 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·players.Find((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.hnsManager.LogicOptionsHnS.ImpostorPlayerID());
53 »       »       »       playerInfo.Object.RpcSetRole(RoleTypes.Impostor);53 »       »       »       networkedPlayerInfo.Object.RpcSetRole(RoleTypes.Impostor,·false);
54 »       »       »       players.Remove(playerInfo);54 »       »       »       players.Remove(networkedPlayerInfo);
55 »       »       »       return;55 »       »       »       return;
56 »       »       }56 »       »       }
57 »       »       this.PickSeekersRoundRobin(players,·teamMax);57 »       »       this.PickSeekersRoundRobin(players,·teamMax);
58 »       }58 »       }
59 59
60 »       private·void·PickSeekersRoundRobin(List<GameData.PlayerInfo>·players,·int·teamMax)60 »       private·void·PickSeekersRoundRobin(List<NetworkedPlayerInfo>·players,·int·teamMax)
61 »       {61 »       {
62 »       »       int·num·=·0;62 »       »       int·num·=·0;
63 »       »       while·(num·<·teamMax·&&·players.Count·>·0)63 »       »       while·(num·<·teamMax·&&·players.Count·>·0)
64 »       »       {64 »       »       {
65 »       »       »       PseudoRandomList<GameData.PlayerInfo>·pseudoRandomList·=·new·PseudoRandomList<GameData.PlayerInfo>(AmongUsClient.Instance.GameId);65 »       »       »       PseudoRandomList<NetworkedPlayerInfo>·pseudoRandomList·=·new·PseudoRandomList<NetworkedPlayerInfo>(AmongUsClient.Instance.GameId);
66 »       »       »       pseudoRandomList.AddRange(players);66 »       »       »       pseudoRandomList.AddRange(players);
67 »       »       »       for·(int·i·=·0;·i·<·TempData.RoundsPlayedInSession;·i++)67 »       »       »       for·(int·i·=·0;·i·<·GameData.RoundsPlayedInSession;·i++)
68 »       »       »       {68 »       »       »       {
69 »       »       »       »       pseudoRandomList.PickRandom();69 »       »       »       »       pseudoRandomList.PickRandom();
70 »       »       »       }70 »       »       »       }
71 »       »       »       GameData.PlayerInfo·playerInfo·=·pseudoRandomList.PickRandom();71 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·pseudoRandomList.PickRandom();
72 »       »       »       playerInfo.Object.RpcSetRole(RoleTypes.Impostor);72 »       »       »       networkedPlayerInfo.Object.RpcSetRole(RoleTypes.Impostor,·false);
73 »       »       »       players.Remove(playerInfo);73 »       »       »       players.Remove(networkedPlayerInfo);
74 »       »       »       num++;74 »       »       »       num++;
75 »       »       }75 »       »       }
76 »       }76 »       }
77 77
78 »       public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole)78 »       public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole)
79 »       {79 »       {
80 »       »       if·(AmongUsClient.Instance.AmHost·&&·assignGhostRole)80 »       »       if·(AmongUsClient.Instance.AmHost·&&·assignGhostRole)
1.86 KB
Assembly-CSharp/LogicRoleSelectionNormal.cs
    
Offset 32, 15 lines modifiedOffset 32, 15 lines modified
32 »       »       return·false;32 »       »       return·false;
33 »       }33 »       }
34 34
35 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)35 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)
36 »       {36 »       {
37 »       }37 »       }
38 38
39 »       public·override·void·AssignRolesForTeam(List<GameData.PlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole)39 »       public·override·void·AssignRolesForTeam(List<NetworkedPlayerInfo>·players,·IGameOptions·opts,·RoleTeamTypes·team,·int·teamMax,·RoleTypes?·defaultRole)
40 »       {40 »       {
41 »       »       int·num·=·0;41 »       »       int·num·=·0;
42 »       »       IEnumerable<RoleBehaviour>·enumerable·=·Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·role.TeamType·==·team·&&·!RoleManager.IsGhostRole(role.Role));42 »       »       IEnumerable<RoleBehaviour>·enumerable·=·Enumerable.Where<RoleBehaviour>(DestroyableSingleton<RoleManager>.Instance.AllRoles,·(RoleBehaviour·role)·=>·role.TeamType·==·team·&&·!RoleManager.IsGhostRole(role.Role));
43 »       »       List<RoleTypes>·list·=·new·List<RoleTypes>();43 »       »       List<RoleTypes>·list·=·new·List<RoleTypes>();
44 »       »       IRoleOptionsCollection·roleOptions·=·opts.RoleOptions;44 »       »       IRoleOptionsCollection·roleOptions·=·opts.RoleOptions;
45 »       »       IEnumerable<RoleBehaviour>·enumerable2·=·enumerable;45 »       »       IEnumerable<RoleBehaviour>·enumerable2·=·enumerable;
46 »       »       Func<RoleBehaviour,·bool>·<>9__4;46 »       »       Func<RoleBehaviour,·bool>·<>9__4;
Offset 94, 23 lines modifiedOffset 94, 23 lines modified
94 »       »       »       {94 »       »       »       {
95 »       »       »       »       list.Add(defaultRole.Value);95 »       »       »       »       list.Add(defaultRole.Value);
96 »       »       »       }96 »       »       »       }
97 »       »       »       this.AssignRolesFromList(players,·teamMax,·list,·ref·num);97 »       »       »       this.AssignRolesFromList(players,·teamMax,·list,·ref·num);
98 »       »       }98 »       »       }
99 »       }99 »       }
100 100
101 »       private·void·AssignRolesFromList(List<GameData.PlayerInfo>·players,·int·teamMax,·List<RoleTypes>·roleList,·ref·int·rolesAssigned)101 »       private·void·AssignRolesFromList(List<NetworkedPlayerInfo>·players,·int·teamMax,·List<RoleTypes>·roleList,·ref·int·rolesAssigned)
102 »       {102 »       {
103 »       »       while·(roleList.Count·>·0·&&·players.Count·>·0·&&·rolesAssigned·<·teamMax)103 »       »       while·(roleList.Count·>·0·&&·players.Count·>·0·&&·rolesAssigned·<·teamMax)
104 »       »       {104 »       »       {
105 »       »       »       int·num·=·HashRandom.FastNext(roleList.Count);105 »       »       »       int·num·=·HashRandom.FastNext(roleList.Count);
106 »       »       »       RoleTypes·roleTypes·=·roleList[num];106 »       »       »       RoleTypes·roleTypes·=·roleList[num];
107 »       »       »       roleList.RemoveAt(num);107 »       »       »       roleList.RemoveAt(num);
108 »       »       »       int·num2·=·HashRandom.FastNext(players.Count);108 »       »       »       int·num2·=·HashRandom.FastNext(players.Count);
109 »       »       »       players[num2].Object.RpcSetRole(roleTypes);109 »       »       »       players[num2].Object.RpcSetRole(roleTypes,·false);
110 »       »       »       players.RemoveAt(num2);110 »       »       »       players.RemoveAt(num2);
111 »       »       »       rolesAssigned++;111 »       »       »       rolesAssigned++;
112 »       »       }112 »       »       }
113 »       }113 »       }
114 114
115 »       public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole)115 »       public·override·void·OnPlayerDeath(PlayerControl·player,·bool·assignGhostRole)
116 »       {116 »       {
655 B
Assembly-CSharp/LongBoiPlayerBody.cs
    
Offset 143, 15 lines modifiedOffset 143, 15 lines modified
143 »       »       »       }143 »       »       »       }
144 »       »       »       if·(this.hideAndSeekImpostor·==·null)144 »       »       »       if·(this.hideAndSeekImpostor·==·null)
145 »       »       »       {145 »       »       »       {
146 »       »       »       »       return;146 »       »       »       »       return;
147 »       »       »       }147 »       »       »       }
148 »       »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)148 »       »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
149 »       »       »       {149 »       »       »       {
150 »       »       »       »       GameData.PlayerInfo·data·=·playerControl.Data;150 »       »       »       »       NetworkedPlayerInfo·data·=·playerControl.Data;
151 »       »       »       »       if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!playerControl.Data.Role.IsImpostor)151 »       »       »       »       if·(((data·!=·null)·?·data.Role·:·null)·!=·null·&&·!playerControl.Data.Role.IsImpostor)
152 »       »       »       »       {152 »       »       »       »       {
153 »       »       »       »       »       playerControl.cosmetics.GetLongBoi().SetHeighFromDistanceHnS((this.hideAndSeekImpostor.transform.position·-·playerControl.transform.position).sqrMagnitude);153 »       »       »       »       »       playerControl.cosmetics.GetLongBoi().SetHeighFromDistanceHnS((this.hideAndSeekImpostor.transform.position·-·playerControl.transform.position).sqrMagnitude);
154 »       »       »       »       }154 »       »       »       »       }
155 »       »       »       }155 »       »       »       }
156 »       »       }156 »       »       }
157 »       }157 »       }
1.0 KB
Assembly-CSharp/LongModeKillAnimation.cs
    
Offset 1, 19 lines modifiedOffset 1, 19 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 public·class·LongModeKillAnimation·:·OverlayKillAnimation4 public·class·LongModeKillAnimation·:·OverlayKillAnimation
5 {5 {
6 »       public·override·void·Initialize(GameData.PlayerInfo·kInfo,·GameData.PlayerInfo·vInfo)6 »       public·override·void·Initialize(KillOverlayInitData·initData)
7 »       {7 »       {
8 »       »       base.Initialize(kInfo,·vInfo);8 »       »       base.Initialize(initData);
9 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerNeck);9 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerNeck);
10 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerHead);10 »       »       PlayerMaterial.SetColors(this.killerParts.ColorId,·this.killerHead);
11 »       »       this.sideHat.SetHat(kInfo.DefaultOutfit.HatId,·this.killerParts.ColorId);11 »       »       this.sideHat.SetHat(initData.killerOutfit.HatId,·this.killerParts.ColorId);
12 »       »       this.sideVisor.SetVisor(kInfo.DefaultOutfit.VisorId,·this.killerParts.ColorId);12 »       »       this.sideVisor.SetVisor(initData.killerOutfit.VisorId,·this.killerParts.ColorId);
13 »       }13 »       }
14 14
15 »       [SerializeField]15 »       [SerializeField]
16 »       private·SpriteRenderer·killerNeck;16 »       private·SpriteRenderer·killerNeck;
17 17
18 »       [SerializeField]18 »       [SerializeField]
19 »       private·SpriteRenderer·killerHead;19 »       private·SpriteRenderer·killerHead;
1.62 KB
Assembly-CSharp/MainMenuManager.cs
    
Offset 115, 17 lines modifiedOffset 115, 17 lines modified
115 »       »       {115 »       »       {
116 »       »       »       DestroyableSingleton<StoreMenu>.Instance.Initialize();116 »       »       »       DestroyableSingleton<StoreMenu>.Instance.Initialize();
117 »       »       }117 »       »       }
118 »       »       while·(!DestroyableSingleton<EOSManager>.Instance.HasFinishedLoginFlow()·||·DestroyableSingleton<AccountManager>.Instance.signInScreen.IsOpen())118 »       »       while·(!DestroyableSingleton<EOSManager>.Instance.HasFinishedLoginFlow()·||·DestroyableSingleton<AccountManager>.Instance.signInScreen.IsOpen())
119 »       »       {119 »       »       {
120 »       »       »       yield·return·new·WaitForSeconds(0.3f);120 »       »       »       yield·return·new·WaitForSeconds(0.3f);
121 »       »       }121 »       »       }
122 »       »       DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·true; 
123 »       »       if·(DataManager.Player.Account.LoginStatus·!=·EOSManager.AccountLoginStatus.Offline)122 »       »       if·(DataManager.Player.Account.LoginStatus·!=·EOSManager.AccountLoginStatus.Offline)
124 »       »       {123 »       »       {
 124 »       »       »       DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·true;
125 »       »       »       base.StartCoroutine(this.announcementPopUp.ShowIfNew(delegate125 »       »       »       base.StartCoroutine(this.announcementPopUp.ShowIfNew(delegate
126 »       »       »       {126 »       »       »       {
127 »       »       »       »       DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·false;127 »       »       »       »       DestroyableSingleton<EOSManager>.Instance.announcementsVisible·=·false;
128 »       »       »       }));128 »       »       »       }));
129 »       »       }129 »       »       }
130 »       »       this.CheckAddOns();130 »       »       this.CheckAddOns();
131 »       »       DestroyableSingleton<StoreMenu>.Instance.OnSaveDataChanged();131 »       »       DestroyableSingleton<StoreMenu>.Instance.OnSaveDataChanged();
Offset 258, 16 lines modifiedOffset 258, 16 lines modified
258 258
259 »       [SerializeField]259 »       [SerializeField]
260 »       private·SpriteRenderer·screenTint;260 »       private·SpriteRenderer·screenTint;
261 261
262 »       [SerializeField]262 »       [SerializeField]
263 »       private·PassiveButton·freePlayButton;263 »       private·PassiveButton·freePlayButton;
264 264
265 »       [SerializeField] 
266 »       [Header("Left·panel·buttons")]265 »       [Header("Left·panel·buttons")]
 266 »       [SerializeField]
267 »       private·PassiveButton·playButton;267 »       private·PassiveButton·playButton;
268 268
269 »       [SerializeField]269 »       [SerializeField]
270 »       private·PassiveButton·inventoryButton;270 »       private·PassiveButton·inventoryButton;
271 271
272 »       [SerializeField]272 »       [SerializeField]
273 »       private·PassiveButton·shopButton;273 »       private·PassiveButton·shopButton;
Offset 283, 16 lines modifiedOffset 283, 16 lines modified
283 283
284 »       [SerializeField]284 »       [SerializeField]
285 »       private·PassiveButton·creditsButton;285 »       private·PassiveButton·creditsButton;
286 286
287 »       [SerializeField]287 »       [SerializeField]
288 »       private·PassiveButton·quitButton;288 »       private·PassiveButton·quitButton;
289 289
290 »       [SerializeField] 
291 »       [Header("Default·right·panel·buttons")]290 »       [Header("Default·right·panel·buttons")]
 291 »       [SerializeField]
292 »       private·PassiveButton·playLocalButton;292 »       private·PassiveButton·playLocalButton;
293 293
294 »       [SerializeField]294 »       [SerializeField]
295 »       private·PassiveButton·howToPlayButton;295 »       private·PassiveButton·howToPlayButton;
296 296
297 »       [SerializeField]297 »       [SerializeField]
298 »       private·PassiveButton·accountCTAButton;298 »       private·PassiveButton·accountCTAButton;
5.61 KB
Assembly-CSharp/MapBehaviour.cs
    
Offset 16, 16 lines modifiedOffset 16, 21 lines modified
16 »       {16 »       {
17 »       »       get17 »       »       get
18 »       »       {18 »       »       {
19 »       »       »       return·this.IsOpen·&&·this.countOverlay.isActiveAndEnabled·&&·!this.countOverlayAllowsMovement;19 »       »       »       return·this.IsOpen·&&·this.countOverlay.isActiveAndEnabled·&&·!this.countOverlayAllowsMovement;
20 »       »       }20 »       »       }
21 »       }21 »       }
22 22
23 »       public·void·SetPreMeetingPosition(Vector3·preMeetingPosition)23 »       public·void·SetPreMeetingPosition(Vector3·preMeetingPosition,·bool·trackedPlayer·=·false)
24 »       {24 »       {
 25 »       »       if·(trackedPlayer)
 26 »       »       {
 27 »       »       »       this.trackedPreMeetingPosition·=·new·Vector3?(preMeetingPosition);
 28 »       »       »       return;
 29 »       »       }
25 »       »       this.preMeetingPosition·=·new·Vector3?(preMeetingPosition);30 »       »       this.preMeetingPosition·=·new·Vector3?(preMeetingPosition);
26 »       }31 »       }
27 32
28 »       public·void·Show(MapOptions·opts)33 »       public·void·Show(MapOptions·opts)
29 »       {34 »       {
30 »       »       if·(this.IsOpen)35 »       »       if·(this.IsOpen)
31 »       »       {36 »       »       {
Offset 57, 20 lines modifiedOffset 62, 30 lines modified
57 »       {62 »       {
58 »       »       global::Logger.GlobalInstance.Debug("GAMEPLAY::MapBehaviour::Closing·map",·null);63 »       »       global::Logger.GlobalInstance.Debug("GAMEPLAY::MapBehaviour::Closing·map",·null);
59 »       »       base.gameObject.SetActive(false);64 »       »       base.gameObject.SetActive(false);
60 »       »       this.countOverlay.gameObject.SetActive(false);65 »       »       this.countOverlay.gameObject.SetActive(false);
61 »       »       this.infectedOverlay.gameObject.SetActive(false);66 »       »       this.infectedOverlay.gameObject.SetActive(false);
62 »       »       this.taskOverlay.Hide();67 »       »       this.taskOverlay.Hide();
63 »       »       this.HerePoint.enabled·=·true;68 »       »       this.HerePoint.enabled·=·true;
 69 »       »       DestroyableSingleton<HudManager>.Instance.DeselectMapButton();
64 »       »       if·(!MeetingHud.Instance)70 »       »       if·(!MeetingHud.Instance)
65 »       »       {71 »       »       {
66 »       »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(true);72 »       »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(true);
67 »       »       }73 »       »       }
68 »       }74 »       }
69 75
 76 »       public·void·DisableTrackerOverlays()
 77 »       {
 78 »       »       global::Logger.GlobalInstance.Debug("GAMEPLAY::MapBehaviour::Closing·Tracker·Overlays",·null);
 79 »       »       if·(this.TrackedHerePoint·!=·null)
 80 »       »       {
 81 »       »       »       this.TrackedHerePoint.gameObject.SetActive(false);
 82 »       »       }
 83 »       }
 84
70 »       private·void·Validate()85 »       private·void·Validate()
71 »       {86 »       {
72 »       »       this.countOverlay.CountAreas.ForEach(delegate(CounterArea·area)87 »       »       this.countOverlay.CountAreas.ForEach(delegate(CounterArea·area)
73 »       »       {88 »       »       {
74 »       »       »       if·(area·==·null)89 »       »       »       if·(area·==·null)
75 »       »       »       {90 »       »       »       {
76 »       »       »       »       Debug.LogError("One·of·the·count·areas·in·the·count·overlay·is·null");91 »       »       »       »       Debug.LogError("One·of·the·count·areas·in·the·count·overlay·is·null");
Offset 122, 28 lines modifiedOffset 137, 42 lines modified
122 »       »       »       return;137 »       »       »       return;
123 »       »       }138 »       »       }
124 »       »       if·(!PlayerControl.LocalPlayer.CanMove·&&·!MeetingHud.Instance)139 »       »       if·(!PlayerControl.LocalPlayer.CanMove·&&·!MeetingHud.Instance)
125 »       »       {140 »       »       {
126 »       »       »       return;141 »       »       »       return;
127 »       »       }142 »       »       }
128 »       »       PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint);143 »       »       PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint);
 144 »       »       if·(PlayerControl.LocalPlayer.isTrackingPlayer)
 145 »       »       {
 146 »       »       »       if·(PlayerControl.LocalPlayer.trackedPlayer.Data.Disconnected)
 147 »       »       »       {
 148 »       »       »       »       this.TrackedHerePoint.gameObject.SetActive(false);
 149 »       »       »       }
 150 »       »       »       else
 151 »       »       »       {
 152 »       »       »       »       this.SetTrackedHerePointColor(PlayerControl.LocalPlayer.trackedPlayerColorID);
 153 »       »       »       »       this.TrackedHerePoint.gameObject.SetActive(true);
 154 »       »       »       »       this.UpdateTrackedPosition();
 155 »       »       »       }
 156 »       »       }
129 »       »       this.GenericShow();157 »       »       this.GenericShow();
130 »       »       this.taskOverlay.Show();158 »       »       this.taskOverlay.Show();
131 »       »       this.ColorControl.SetColor(new·Color(0.05f,·0.2f,·1f,·1f));159 »       »       this.ColorControl.SetColor(new·Color(0.05f,·0.2f,·1f,·1f));
132 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(false);160 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(false);
133 »       }161 »       }
134 162
135 »       private·void·ShowCountOverlay(bool·allowedToMove,·bool·showLivePlayerPosition,·bool·includeDeadBodies)163 »       private·void·ShowCountOverlay(bool·allowedToMove,·bool·showLivePlayerPosition,·bool·includeDeadBodies)
136 »       {164 »       {
137 »       »       this.GenericShow();165 »       »       this.GenericShow();
138 »       »       this.countOverlay.gameObject.SetActive(true);166 »       »       this.countOverlay.gameObject.SetActive(true);
139 »       »       this.countOverlay.SetOptions(showLivePlayerPosition,·includeDeadBodies);167 »       »       this.countOverlay.SetOptions(showLivePlayerPosition,·includeDeadBodies);
140 »       »       this.countOverlayAllowsMovement·=·allowedToMove;168 »       »       this.countOverlayAllowsMovement·=·allowedToMove;
141 »       »       this.taskOverlay.Hide();169 »       »       this.taskOverlay.Hide();
142 »       »       this.HerePoint.enabled·=·!showLivePlayerPosition;170 »       »       this.HerePoint.enabled·=·!showLivePlayerPosition;
 171 »       »       this.TrackedHerePoint.gameObject.SetActive(false);
143 »       »       if·(this.HerePoint.enabled)172 »       »       if·(this.HerePoint.enabled)
144 »       »       {173 »       »       {
145 »       »       »       PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint);174 »       »       »       PlayerControl.LocalPlayer.SetPlayerMaterialColors(this.HerePoint);
146 »       »       }175 »       »       }
147 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(false);176 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(false);
148 »       }177 »       }
149 178
Offset 162, 14 lines modifiedOffset 191, 23 lines modified
162 »       »       {191 »       »       {
163 »       »       »       this.preMeetingPosition·=·null;192 »       »       »       this.preMeetingPosition·=·null;
164 »       »       }193 »       »       }
165 »       »       vector·/=·ShipStatus.Instance.MapScale;194 »       »       vector·/=·ShipStatus.Instance.MapScale;
166 »       »       vector.x·*=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x);195 »       »       vector.x·*=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x);
167 »       »       vector.z·=·-1f;196 »       »       vector.z·=·-1f;
168 »       »       this.HerePoint.transform.localPosition·=·vector;197 »       »       this.HerePoint.transform.localPosition·=·vector;
 198 »       »       if·(PlayerControl.LocalPlayer.isTrackingPlayer)
 199 »       »       {
 200 »       »       »       this.trackedPointDelayTime·+=·Time.deltaTime;
 201 »       »       »       if·(this.trackedPointDelayTime·>=·GameManager.Instance.LogicOptions.GetTrackerDelay())
 202 »       »       »       {
 203 »       »       »       »       this.UpdateTrackedPosition();
 204 »       »       »       »       this.trackedPointDelayTime·=·0f;
 205 »       »       »       }
 206 »       »       }
169 »       }207 »       }
170 208
171 »       private·void·Awake()209 »       private·void·Awake()
172 »       {210 »       {
173 »       »       MapBehaviour.Instance·=·this;211 »       »       MapBehaviour.Instance·=·this;
174 »       »       this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>();212 »       »       this.specialInputHandler·=·base.GetComponent<SpecialInputHandler>();
175 »       }213 »       }
Offset 182, 31 lines modifiedOffset 220, 67 lines modified
182 »       »       if·(Mathf.Sign(localScale.x)·!=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x))220 »       »       if·(Mathf.Sign(localScale.x)·!=·Mathf.Sign(ShipStatus.Instance.transform.localScale.x))
183 »       »       {221 »       »       {
184 »       »       »       localScale.x·*=·-1f;222 »       »       »       localScale.x·*=·-1f;
185 »       »       }223 »       »       }
186 »       »       this.taskOverlay.transform.localScale·=·localScale;224 »       »       this.taskOverlay.transform.localScale·=·localScale;
187 »       »       this.fadedBackground.SetActive(MeetingHud.Instance);225 »       »       this.fadedBackground.SetActive(MeetingHud.Instance);
188 »       »       this.HerePoint.material.SetInt(PlayerMaterial.MaskLayer,·255);226 »       »       this.HerePoint.material.SetInt(PlayerMaterial.MaskLayer,·255);
Max diff block lines reached; 1535/5680 bytes (27.02%) of diff not shown.
640 B
Assembly-CSharp/MapConsole.cs
    
Offset 33, 15 lines modifiedOffset 33, 15 lines modified
33 »       »       {33 »       »       {
34 »       »       »       this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));34 »       »       »       this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));
35 »       »       »       this.Image.material.SetColor("_OutlineColor",·Color.white);35 »       »       »       this.Image.material.SetColor("_OutlineColor",·Color.white);
36 »       »       »       this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear);36 »       »       »       this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear);
37 »       »       }37 »       »       }
38 »       }38 »       }
39 39
40 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)40 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
41 »       {41 »       {
42 »       »       float·num·=·float.MaxValue;42 »       »       float·num·=·float.MaxValue;
43 »       »       PlayerControl·@object·=·pc.Object;43 »       »       PlayerControl·@object·=·pc.Object;
44 »       »       couldUse·=·pc.Object.CanMove;44 »       »       couldUse·=·pc.Object.CanMove;
45 »       »       canUse·=·couldUse;45 »       »       canUse·=·couldUse;
46 »       »       if·(canUse)46 »       »       if·(canUse)
47 »       »       {47 »       »       {
1.58 KB
Assembly-CSharp/MedScanMinigame.cs
    
Offset 8, 15 lines modifiedOffset 8, 15 lines modified
8 {8 {
9 »       public·override·void·Begin(PlayerTask·task)9 »       public·override·void·Begin(PlayerTask·task)
10 »       {10 »       {
11 »       »       base.Begin(task);11 »       »       base.Begin(task);
12 »       »       this.medscan·=·ShipStatus.Instance.Systems[SystemTypes.MedBay]·as·MedScanSystem;12 »       »       this.medscan·=·ShipStatus.Instance.Systems[SystemTypes.MedBay]·as·MedScanSystem;
13 »       »       this.gauge.Value·=·0f;13 »       »       this.gauge.Value·=·0f;
14 »       »       base.transform.position·=·new·Vector3(100f,·0f,·0f);14 »       »       base.transform.position·=·new·Vector3(100f,·0f,·0f);
15 »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;15 »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
16 »       »       int·playerId·=·(int)data.PlayerId;16 »       »       int·playerId·=·(int)data.PlayerId;
17 »       »       string·colorName·=·Palette.GetColorName(data.DefaultOutfit.ColorId.Wrap(Palette.ColorNames.Length));17 »       »       string·colorName·=·Palette.GetColorName(data.DefaultOutfit.ColorId.Wrap(Palette.ColorNames.Length));
18 »       »       StringBuilder·stringBuilder·=·new·StringBuilder();18 »       »       StringBuilder·stringBuilder·=·new·StringBuilder();
19 »       »       stringBuilder.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedID,·Array.Empty<object>())·+·"·");19 »       »       stringBuilder.Append(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedID,·Array.Empty<object>())·+·"·");
20 »       »       string·text·=·colorName.ToUpperInvariant();20 »       »       string·text·=·colorName.ToUpperInvariant();
21 »       »       if·(text.Length·>·3)21 »       »       if·(text.Length·>·3)
22 »       »       {22 »       »       {
Offset 79, 15 lines modifiedOffset 79, 15 lines modified
79 »       »       if·(this.medscan.CurrentUser·!=·playerId)79 »       »       if·(this.medscan.CurrentUser·!=·playerId)
80 »       »       {80 »       »       {
81 »       »       »       if·(this.medscan.CurrentUser·==·255)81 »       »       »       if·(this.medscan.CurrentUser·==·255)
82 »       »       »       {82 »       »       »       {
83 »       »       »       »       this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanRequested,·Array.Empty<object>());83 »       »       »       »       this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanRequested,·Array.Empty<object>());
84 »       »       »       »       return;84 »       »       »       »       return;
85 »       »       »       }85 »       »       »       }
86 »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.medscan.CurrentUser);86 »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(this.medscan.CurrentUser);
87 »       »       »       this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanWaitingFor,·new·object[]·{·playerById.PlayerName·});87 »       »       »       this.text.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.MedscanWaitingFor,·new·object[]·{·playerById.PlayerName·});
88 »       »       »       return;88 »       »       »       return;
89 »       »       }89 »       »       }
90 »       »       else90 »       »       else
91 »       »       {91 »       »       {
92 »       »       »       if·(this.state·!=·MedScanMinigame.PositionState.WalkingToPad)92 »       »       »       if·(this.state·!=·MedScanMinigame.PositionState.WalkingToPad)
93 »       »       »       {93 »       »       »       {
756 B
Assembly-CSharp/MeetingCalledAnimation.cs
    
Offset 1, 16 lines modifiedOffset 1, 16 lines modified
1 using·System;1 using·System;
2 using·System.Collections;2 using·System.Collections;
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·class·MeetingCalledAnimation·:·OverlayAnimation5 public·class·MeetingCalledAnimation·:·OverlayAnimation
6 {6 {
7 »       public·void·Initialize(GameData.PlayerInfo·reportInfo)7 »       public·void·Initialize(NetworkedPlayerInfo.PlayerOutfit·outfit)
8 »       {8 »       {
9 »       »       this.playerParts.UpdateFromEitherPlayerDataOrCache(reportInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.None,·false,·null);9 »       »       this.playerParts.UpdateFromPlayerOutfit(outfit,·PlayerMaterial.MaskType.None,·false,·false,·null,·false);
10 »       }10 »       }
11 11
12 »       public·override·IEnumerator·CoShow(KillOverlay·parent)12 »       public·override·IEnumerator·CoShow(KillOverlay·parent)
13 »       {13 »       {
14 »       »       base.gameObject.SetActive(true);14 »       »       base.gameObject.SetActive(true);
15 »       »       if·(Constants.ShouldPlaySfx())15 »       »       if·(Constants.ShouldPlaySfx())
16 »       »       {16 »       »       {
15.0 KB
Assembly-CSharp/MeetingHud.cs
    
Offset 28, 15 lines modifiedOffset 28, 15 lines modified
28 »       »       }28 »       »       }
29 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpcImmediately(this.NetId,·24,·SendOption.Reliable,·AmongUsClient.Instance.HostId);29 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpcImmediately(this.NetId,·24,·SendOption.Reliable,·AmongUsClient.Instance.HostId);
30 »       »       messageWriter.Write(playerId);30 »       »       messageWriter.Write(playerId);
31 »       »       messageWriter.Write(suspectIdx);31 »       »       messageWriter.Write(suspectIdx);
32 »       »       AmongUsClient.Instance.FinishRpcImmediately(messageWriter);32 »       »       AmongUsClient.Instance.FinishRpcImmediately(messageWriter);
33 »       }33 »       }
34 34
35 »       private·void·RpcVotingComplete(MeetingHud.VoterState[]·states,·GameData.PlayerInfo·exiled,·bool·tie)35 »       private·void·RpcVotingComplete(MeetingHud.VoterState[]·states,·NetworkedPlayerInfo·exiled,·bool·tie)
36 »       {36 »       {
37 »       »       if·(AmongUsClient.Instance.AmClient)37 »       »       if·(AmongUsClient.Instance.AmClient)
38 »       »       {38 »       »       {
39 »       »       »       this.VotingComplete(states,·exiled,·tie);39 »       »       »       this.VotingComplete(states,·exiled,·tie);
40 »       »       }40 »       »       }
41 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·23,·SendOption.Reliable);41 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·23,·SendOption.Reliable);
42 »       »       messageWriter.WritePacked(states.Length);42 »       »       messageWriter.WritePacked(states.Length);
Offset 66, 15 lines modifiedOffset 66, 18 lines modified
66 »       »       for·(int·i·=·0;·i·<·this.playerStates.Length;·i++)66 »       »       for·(int·i·=·0;·i·<·this.playerStates.Length;·i++)
67 »       »       {67 »       »       {
68 »       »       »       PlayerVoteArea·playerVoteArea·=·this.playerStates[i];68 »       »       »       PlayerVoteArea·playerVoteArea·=·this.playerStates[i];
69 »       »       »       writer.StartMessage(playerVoteArea.TargetPlayerId);69 »       »       »       writer.StartMessage(playerVoteArea.TargetPlayerId);
70 »       »       »       this.playerStates[i].Serialize(writer);70 »       »       »       this.playerStates[i].Serialize(writer);
71 »       »       »       writer.EndMessage();71 »       »       »       writer.EndMessage();
72 »       »       }72 »       »       }
 73 »       »       if·(!initialState)
 74 »       »       {
73 »       »       base.ClearDirtyBits();75 »       »       »       base.ClearDirtyBits();
 76 »       »       }
74 »       »       return·true;77 »       »       return·true;
75 »       }78 »       }
76 79
77 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)80 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)
78 »       {81 »       {
79 »       »       if·(initialState)82 »       »       if·(initialState)
80 »       »       {83 »       »       {
Offset 106, 15 lines modifiedOffset 109, 15 lines modified
106 »       »       case·23:109 »       »       case·23:
107 »       »       {110 »       »       {
108 »       »       »       MeetingHud.VoterState[]·array·=·new·MeetingHud.VoterState[reader.ReadPackedInt32()];111 »       »       »       MeetingHud.VoterState[]·array·=·new·MeetingHud.VoterState[reader.ReadPackedInt32()];
109 »       »       »       for·(int·i·=·0;·i·<·array.Length;·i++)112 »       »       »       for·(int·i·=·0;·i·<·array.Length;·i++)
110 »       »       »       {113 »       »       »       {
111 »       »       »       »       array[i]·=·MeetingHud.VoterState.Deserialize(reader);114 »       »       »       »       array[i]·=·MeetingHud.VoterState.Deserialize(reader);
112 »       »       »       }115 »       »       »       }
113 »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(reader.ReadByte());116 »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(reader.ReadByte());
114 »       »       »       bool·flag·=·reader.ReadBoolean();117 »       »       »       bool·flag·=·reader.ReadBoolean();
115 »       »       »       this.VotingComplete(array,·playerById,·flag);118 »       »       »       this.VotingComplete(array,·playerById,·flag);
116 »       »       »       return;119 »       »       »       return;
117 »       »       }120 »       »       }
118 »       »       case·24:121 »       »       case·24:
119 »       »       {122 »       »       {
120 »       »       »       byte·b·=·reader.ReadByte();123 »       »       »       byte·b·=·reader.ReadByte();
Offset 126, 14 lines modifiedOffset 129, 22 lines modified
126 »       »       »       this.ClearVote();129 »       »       »       this.ClearVote();
127 »       »       »       return;130 »       »       »       return;
128 »       »       default:131 »       »       default:
129 »       »       »       return;132 »       »       »       return;
130 »       »       }133 »       »       }
131 »       }134 »       }
132 135
 136 »       public·bool·IsPersistent
 137 »       {
 138 »       »       get
 139 »       »       {
 140 »       »       »       return·false;
 141 »       »       }
 142 »       }
 143
133 »       public·MeetingHud.VoteStates·CurrentState144 »       public·MeetingHud.VoteStates·CurrentState
134 »       {145 »       {
135 »       »       get146 »       »       get
136 »       »       {147 »       »       {
137 »       »       »       return·this.state;148 »       »       »       return·this.state;
138 »       »       }149 »       »       }
139 »       }150 »       }
Offset 289, 26 lines modifiedOffset 300, 26 lines modified
289 »       »       SpriteRenderer[]·outerMasks·=·this.OuterMasks;300 »       »       SpriteRenderer[]·outerMasks·=·this.OuterMasks;
290 »       »       for·(int·i·=·0;·i·<·outerMasks.Length;·i++)301 »       »       for·(int·i·=·0;·i·<·outerMasks.Length;·i++)
291 »       »       {302 »       »       {
292 »       »       »       outerMasks[i].enabled·=·enabled;303 »       »       »       outerMasks[i].enabled·=·enabled;
293 »       »       }304 »       »       }
294 »       }305 »       }
295 306
296 »       public·IEnumerator·CoIntro(GameData.PlayerInfo·reporter,·GameData.PlayerInfo·reportedBody,·GameData.PlayerInfo[]·deadBodies)307 »       public·IEnumerator·CoIntro(NetworkedPlayerInfo·reporter,·NetworkedPlayerInfo·reportedBody,·NetworkedPlayerInfo[]·deadBodies)
297 »       {308 »       {
298 »       »       this.SkipVoteButton.SetDisabled();309 »       »       this.SkipVoteButton.SetDisabled();
299 »       »       base.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);310 »       »       base.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform);
300 »       »       base.transform.localPosition·=·Vector3.zero;311 »       »       base.transform.localPosition·=·Vector3.zero;
301 »       »       this.meetingContents.localPosition·=·new·Vector3(0f,·-10f,·0f);312 »       »       this.meetingContents.localPosition·=·new·Vector3(0f,·-10f,·0f);
302 »       »       DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed();313 »       »       DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed();
303 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(false);314 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(false);
304 »       »       bool·flag·=·reportedBody·==·null;315 »       »       bool·flag·=·reportedBody·==·null;
305 »       »       MeetingCalledAnimation·meetingCalledAnimation·=·(flag·?·ShipStatus.Instance.EmergencyOverlay·:·ShipStatus.Instance.ReportOverlay);316 »       »       MeetingCalledAnimation·meetingCalledAnimation·=·(flag·?·ShipStatus.Instance.EmergencyOverlay·:·ShipStatus.Instance.ReportOverlay);
306 »       »       GameData.PlayerInfo·playerInfo·=·(flag·?·reporter·:·reportedBody);317 »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·(flag·?·reporter·:·reportedBody);
307 »       »       DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowMeeting(meetingCalledAnimation,·playerInfo);318 »       »       DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowMeeting(meetingCalledAnimation,·networkedPlayerInfo.DefaultOutfit);
308 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.KillOverlay.WaitForFinish();319 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.KillOverlay.WaitForFinish();
309 »       »       this.MeetingIntro.Init(reporter,·deadBodies);320 »       »       this.MeetingIntro.Init(reporter,·deadBodies);
310 »       »       this.SetMasksEnabled(true);321 »       »       this.SetMasksEnabled(true);
311 »       »       yield·return·Effects.Slide2D(this.meetingContents,·new·Vector2(0f,·-10f),·new·Vector2(0f,·0f),·0.25f);322 »       »       yield·return·Effects.Slide2D(this.meetingContents,·new·Vector2(0f,·-10f),·new·Vector2(0f,·0f),·0.25f);
312 »       »       yield·return·Effects.Wait(0.5f);323 »       »       yield·return·Effects.Wait(0.5f);
313 »       »       yield·return·this.MeetingIntro.CoRun();324 »       »       yield·return·this.MeetingIntro.CoRun();
314 »       »       this.SetMasksEnabled(false);325 »       »       this.SetMasksEnabled(false);
Offset 322, 15 lines modifiedOffset 333, 15 lines modified
322 »       private·IEnumerator·CoStartCutscene()333 »       private·IEnumerator·CoStartCutscene()
323 »       {334 »       {
324 »       »       ConsoleJoystick.SetMode_Task();335 »       »       ConsoleJoystick.SetMode_Task();
325 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·1f,·false);336 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·1f,·false);
326 »       »       ExileController·exileController·=·Object.Instantiate<ExileController>(ShipStatus.Instance.ExileCutscenePrefab);337 »       »       ExileController·exileController·=·Object.Instantiate<ExileController>(ShipStatus.Instance.ExileCutscenePrefab);
327 »       »       exileController.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform,·false);338 »       »       exileController.transform.SetParent(DestroyableSingleton<HudManager>.Instance.transform,·false);
328 »       »       exileController.transform.localPosition·=·new·Vector3(0f,·0f,·-60f);339 »       »       exileController.transform.localPosition·=·new·Vector3(0f,·0f,·-60f);
329 »       »       exileController.Begin(this.exiledPlayer,·this.wasTie);340 »       »       exileController.BeginForGameplay(this.exiledPlayer,·this.wasTie);
330 »       »       this.DespawnOnDestroy·=·false;341 »       »       this.DespawnOnDestroy·=·false;
331 »       »       if·(MapBehaviour.Instance)342 »       »       if·(MapBehaviour.Instance)
332 »       »       {343 »       »       {
333 »       »       »       MapBehaviour.Instance.Close();344 »       »       »       MapBehaviour.Instance.Close();
334 »       »       }345 »       »       }
335 »       »       Object.Destroy(base.gameObject);346 »       »       Object.Destroy(base.gameObject);
336 »       »       yield·break;347 »       »       yield·break;
Offset 340, 21 lines modifiedOffset 351, 21 lines modified
340 »       {351 »       {
341 »       »       this.reporterId·=·reporter;352 »       »       this.reporterId·=·reporter;
342 »       »       this.PopulateButtons(reporter);353 »       »       this.PopulateButtons(reporter);
343 »       }354 »       }
344 355
345 »       public·void·Close()356 »       public·void·Close()
346 »       {357 »       {
347 »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;358 »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
348 »       »       DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(data.IsDead);359 »       »       DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(data.IsDead);
349 »       »       DestroyableSingleton<HudManager>.Instance.Chat.HideBanButton();360 »       »       DestroyableSingleton<HudManager>.Instance.Chat.HideBanButton();
Max diff block lines reached; 10143/15307 bytes (66.26%) of diff not shown.
815 B
Assembly-CSharp/MeetingIntroAnimation.cs
    
Offset 13, 15 lines modifiedOffset 13, 15 lines modified
13 »       »       SpriteRenderer[]·outsideMasks·=·this.OutsideMasks;13 »       »       SpriteRenderer[]·outsideMasks·=·this.OutsideMasks;
14 »       »       for·(int·i·=·0;·i·<·outsideMasks.Length;·i++)14 »       »       for·(int·i·=·0;·i·<·outsideMasks.Length;·i++)
15 »       »       {15 »       »       {
16 »       »       »       outsideMasks[i].material.SetInt(PlayerMaterial.MaskLayer,·254);16 »       »       »       outsideMasks[i].material.SetInt(PlayerMaterial.MaskLayer,·254);
17 »       »       }17 »       »       }
18 »       }18 »       }
19 19
20 »       public·void·Init(GameData.PlayerInfo·reporter,·GameData.PlayerInfo[]·deadBodies)20 »       public·void·Init(NetworkedPlayerInfo·reporter,·NetworkedPlayerInfo[]·deadBodies)
21 »       {21 »       {
22 »       »       PlayerVoteArea·playerVoteArea·=·Object.Instantiate<PlayerVoteArea>(this.VoteAreaPrefab,·this.OverlayParent);22 »       »       PlayerVoteArea·playerVoteArea·=·Object.Instantiate<PlayerVoteArea>(this.VoteAreaPrefab,·this.OverlayParent);
23 »       »       playerVoteArea.transform.localPosition·=·this.ReporterPos;23 »       »       playerVoteArea.transform.localPosition·=·this.ReporterPos;
24 »       »       playerVoteArea.SetMaskLayer(0);24 »       »       playerVoteArea.SetMaskLayer(0);
25 »       »       playerVoteArea.SetCosmetics(reporter);25 »       »       playerVoteArea.SetCosmetics(reporter);
26 »       »       playerVoteArea.SetDead(true,·false,·false);26 »       »       playerVoteArea.SetDead(true,·false,·false);
27 »       »       float·num·=·this.background.size.x·/·2f;27 »       »       float·num·=·this.background.size.x·/·2f;
858 B
Assembly-CSharp/MeetingRoomManager.cs
    
Offset 1, 12 lines modifiedOffset 1, 20 lines modified
1 using·System;1 using·System;
2 2
3 public·class·MeetingRoomManager·:·IDisconnectHandler3 public·class·MeetingRoomManager·:·IDisconnectHandler
4 {4 {
 5 »       public·bool·IsPersistent
 6 »       {
 7 »       »       get
 8 »       »       {
 9 »       »       »       return·false;
 10 »       »       }
 11 »       }
 12
5 »       public·void·AssignSelf(PlayerControl·reporter,·GameData.PlayerInfo·target)13 »       public·void·AssignSelf(PlayerControl·reporter,·NetworkedPlayerInfo·target)
6 »       {14 »       {
7 »       »       this.reporter·=·reporter;15 »       »       this.reporter·=·reporter;
8 »       »       this.target·=·target;16 »       »       this.target·=·target;
9 »       »       AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);17 »       »       AmongUsClient.Instance.DisconnectHandlers.AddUnique(this);
10 »       }18 »       }
11 19
12 »       public·void·RemoveSelf()20 »       public·void·RemoveSelf()
Offset 27, 9 lines modifiedOffset 35, 9 lines modified
27 »       »       this.HandleDisconnect(null,·DisconnectReasons.Unknown);35 »       »       this.HandleDisconnect(null,·DisconnectReasons.Unknown);
28 »       }36 »       }
29 37
30 »       public·static·readonly·MeetingRoomManager·Instance·=·new·MeetingRoomManager();38 »       public·static·readonly·MeetingRoomManager·Instance·=·new·MeetingRoomManager();
31 39
32 »       private·PlayerControl·reporter;40 »       private·PlayerControl·reporter;
33 41
34 »       private·GameData.PlayerInfo·target;42 »       private·NetworkedPlayerInfo·target;
35 }43 }
1.58 KB
Assembly-CSharp/MineOreMinigame.cs
Ordering differences only
    
Offset 336, 36 lines modifiedOffset 336, 36 lines modified
336 336
337 »       private·const·int·ORE_NUMBER·=·3;337 »       private·const·int·ORE_NUMBER·=·3;
338 338
339 »       private·const·int·MAX_GOOD_ROCKS·=·2;339 »       private·const·int·MAX_GOOD_ROCKS·=·2;
340 340
341 »       private·const·int·MAX_PERFECT_ROCKS·=·4;341 »       private·const·int·MAX_PERFECT_ROCKS·=·4;
342 342
343 »       [Tooltip("Speed·of·power·meter·when·breaking·rocks")] 
344 »       [SerializeField]343 »       [SerializeField]
 344 »       [Tooltip("Speed·of·power·meter·when·breaking·rocks")]
345 »       private·float·powerBarSpeed·=·1f;345 »       private·float·powerBarSpeed·=·1f;
346 346
347 »       [SerializeField]347 »       [SerializeField]
348 »       [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")]348 »       [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")]
349 »       private·float·pikeaxeFirstAngle·=·-90f;349 »       private·float·pikeaxeFirstAngle·=·-90f;
350 350
351 »       [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")] 
352 »       [SerializeField]351 »       [SerializeField]
 352 »       [Tooltip("angle·of·pickaxe·while·animating·breaking·a·rock")]
353 »       private·float·pikeaxeSecondAngle·=·50f;353 »       private·float·pikeaxeSecondAngle·=·50f;
354 354
355 »       [Tooltip("time·of·pickeaxe·animation·in·seconds")]355 »       [Tooltip("time·of·pickeaxe·animation·in·seconds")]
356 »       [SerializeField]356 »       [SerializeField]
357 »       private·float·pikeaxeAnimTime·=·0.3f;357 »       private·float·pikeaxeAnimTime·=·0.3f;
358 358
359 »       [SerializeField] 
360 »       [Tooltip("Good·Zone·percentage·max·value")]359 »       [Tooltip("Good·Zone·percentage·max·value")]
 360 »       [SerializeField]
361 »       private·float·goodPercentage·=·0.5f;361 »       private·float·goodPercentage·=·0.5f;
362 362
363 »       [SerializeField] 
364 »       [Tooltip("Great·Zone·percentage·max·value")]363 »       [Tooltip("Great·Zone·percentage·max·value")]
 364 »       [SerializeField]
365 »       private·float·greatPercentage·=·0.8f;365 »       private·float·greatPercentage·=·0.8f;
366 366
367 »       [SerializeField]367 »       [SerializeField]
368 »       private·Collider2D·pickaxe;368 »       private·Collider2D·pickaxe;
369 369
370 »       [SerializeField]370 »       [SerializeField]
371 »       private·GameObject·pickaxeSprite;371 »       private·GameObject·pickaxeSprite;
Offset 375, 16 lines modifiedOffset 375, 16 lines modified
375 375
376 »       [SerializeField]376 »       [SerializeField]
377 »       private·PowerBarMining·powerBarMining;377 »       private·PowerBarMining·powerBarMining;
378 378
379 »       [SerializeField]379 »       [SerializeField]
380 »       private·List<CollectableOre>·ores;380 »       private·List<CollectableOre>·ores;
381 381
382 »       [Header("Audio·Files")] 
383 »       [SerializeField]382 »       [SerializeField]
 383 »       [Header("Audio·Files")]
384 »       private·AudioClip[]·rockHitWeak;384 »       private·AudioClip[]·rockHitWeak;
385 385
386 »       [SerializeField]386 »       [SerializeField]
387 »       private·AudioClip[]·rockHitStrong;387 »       private·AudioClip[]·rockHitStrong;
388 388
389 »       [SerializeField]389 »       [SerializeField]
390 »       private·AudioClip[]·rockRelease;390 »       private·AudioClip[]·rockRelease;
812 B
Assembly-CSharp/Minigame.cs
    
Offset 112, 15 lines modifiedOffset 112, 15 lines modified
112 »       »       »       if·(PlayerControl.LocalPlayer)112 »       »       »       if·(PlayerControl.LocalPlayer)
113 »       »       »       {113 »       »       »       {
114 »       »       »       »       PlayerControl.HideCursorTemporarily();114 »       »       »       »       PlayerControl.HideCursorTemporarily();
115 »       »       »       }115 »       »       »       }
116 »       »       »       this.amClosing·=·Minigame.CloseState.Closing;116 »       »       »       this.amClosing·=·Minigame.CloseState.Closing;
117 »       »       »       this.logger.Info("Closing·minigame·"·+·base.GetType().Name,·null);117 »       »       »       this.logger.Info("Closing·minigame·"·+·base.GetType().Name,·null);
118 »       »       »       IAnalyticsReporter·analytics·=·DestroyableSingleton<DebugAnalytics>.Instance.Analytics;118 »       »       »       IAnalyticsReporter·analytics·=·DestroyableSingleton<DebugAnalytics>.Instance.Analytics;
119 »       »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;119 »       »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
120 »       »       »       TaskTypes·taskType·=·this.TaskType;120 »       »       »       TaskTypes·taskType·=·this.TaskType;
121 »       »       »       float·num·=·Time.realtimeSinceStartup·-·this.timeOpened;121 »       »       »       float·num·=·Time.realtimeSinceStartup·-·this.timeOpened;
122 »       »       »       PlayerTask·myTask·=·this.MyTask;122 »       »       »       PlayerTask·myTask·=·this.MyTask;
123 »       »       »       analytics.MinigameClosed(data,·taskType,·num,·myTask·!=·null·&&·myTask.IsComplete);123 »       »       »       analytics.MinigameClosed(data,·taskType,·num,·myTask·!=·null·&&·myTask.IsComplete);
124 »       »       »       base.StartCoroutine(this.CoDestroySelf());124 »       »       »       base.StartCoroutine(this.CoDestroySelf());
125 »       »       »       return;125 »       »       »       return;
126 »       »       }126 »       »       }
1.73 KB
Assembly-CSharp/MiraExileController.cs
    
Offset 2, 33 lines modifiedOffset 2, 43 lines modified
2 using·System.Collections;2 using·System.Collections;
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·class·MiraExileController·:·ExileController5 public·class·MiraExileController·:·ExileController
6 {6 {
7 »       protected·override·IEnumerator·Animate()7 »       protected·override·IEnumerator·Animate()
8 »       {8 »       {
 9 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 10 »       »       {
9 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);11 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);
 12 »       »       }
10 »       »       yield·return·Effects.All(new·IEnumerator[]13 »       »       yield·return·Effects.All(new·IEnumerator[]
11 »       »       {14 »       »       {
12 »       »       »       this.PlayerSpin(),15 »       »       »       this.PlayerSpin(),
13 »       »       »       this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f),16 »       »       »       this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f),
14 »       »       »       Effects.Slide2D(this.BackgroundClouds,·new·Vector2(0f,·-3f),·new·Vector2(0f,·0.5f),·this.Duration),17 »       »       »       Effects.Slide2D(this.BackgroundClouds,·new·Vector2(0f,·-3f),·new·Vector2(0f,·0.5f),·this.Duration),
15 »       »       »       Effects.Sequence(new·IEnumerator[]18 »       »       »       Effects.Sequence(new·IEnumerator[]
16 »       »       »       {19 »       »       »       {
17 »       »       »       »       Effects.Wait(2f),20 »       »       »       »       Effects.Wait(2f),
18 »       »       »       »       Effects.Slide2D(this.ForegroundClouds,·new·Vector2(0f,·-7f),·new·Vector2(0f,·2.5f),·0.75f)21 »       »       »       »       Effects.Slide2D(this.ForegroundClouds,·new·Vector2(0f,·-7f),·new·Vector2(0f,·2.5f),·0.75f)
19 »       »       »       })22 »       »       »       })
20 »       »       });23 »       »       });
21 »       »       if·(GameManager.Instance.LogicOptions.GetConfirmImpostor())24 »       »       if·(this.initData.confirmImpostor)
22 »       »       {25 »       »       {
23 »       »       »       this.ImpostorText.gameObject.SetActive(true);26 »       »       »       this.ImpostorText.gameObject.SetActive(true);
24 »       »       }27 »       »       }
25 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);28 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);
26 »       »       yield·return·new·WaitForSeconds(0.5f);29 »       »       yield·return·new·WaitForSeconds(0.5f);
 30 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 31 »       »       {
27 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);32 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);
 33 »       »       }
 34 »       »       else
 35 »       »       {
 36 »       »       »       yield·return·Effects.Wait(0.2f);
 37 »       »       }
28 »       »       base.WrapUp();38 »       »       base.WrapUp();
29 »       »       yield·break;39 »       »       yield·break;
30 »       }40 »       }
31 41
32 »       private·IEnumerator·PlayerSpin()42 »       private·IEnumerator·PlayerSpin()
33 »       {43 »       {
34 »       »       float·num·=·Camera.main.orthographicSize·+·1f;44 »       »       float·num·=·Camera.main.orthographicSize·+·1f;
2.12 KB
Assembly-CSharp/Mushroom.cs
    
Offset 116, 15 lines modifiedOffset 116, 15 lines modified
116 »       »       if·(!PlayerControl.LocalPlayer)116 »       »       if·(!PlayerControl.LocalPlayer)
117 »       »       {117 »       »       {
118 »       »       »       source.volume·=·0f;118 »       »       »       source.volume·=·0f;
119 »       »       »       return;119 »       »       »       return;
120 »       »       }120 »       »       }
121 »       »       source.volume·=·1f;121 »       »       source.volume·=·1f;
122 »       »       Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition();122 »       »       Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition();
123 »       »       source.volume·=·SoundManager.GetSoundVolume(base.transform.position,·truePosition,·2f,·6f);123 »       »       source.volume·=·SoundManager.GetSoundVolume(base.transform.position,·truePosition,·2f,·6f,·0f);
124 »       }124 »       }
125 125
126 »       private·const·float·TRIGGER_WAIT_TIME·=·0.5f;126 »       private·const·float·TRIGGER_WAIT_TIME·=·0.5f;
127 127
128 »       private·const·string·SFX_ACTIVATE_NAME·=·"SporeActivate";128 »       private·const·string·SFX_ACTIVATE_NAME·=·"SporeActivate";
129 129
130 »       private·const·string·SFX_SPAWN_NAME·=·"MushroomSpawn";130 »       private·const·string·SFX_SPAWN_NAME·=·"MushroomSpawn";
Offset 145, 63 lines modifiedOffset 145, 63 lines modified
145 145
146 »       [SerializeField]146 »       [SerializeField]
147 »       private·SpriteRenderer·spores;147 »       private·SpriteRenderer·spores;
148 148
149 »       [SerializeField]149 »       [SerializeField]
150 »       private·GameObject·sporeMask;150 »       private·GameObject·sporeMask;
151 151
152 »       [SerializeField] 
153 »       [Tooltip("Use·Fix·Mushroom·IDs·to·auto-set·this·value·for·all·mushrooms·on·the·map.")]152 »       [Tooltip("Use·Fix·Mushroom·IDs·to·auto-set·this·value·for·all·mushrooms·on·the·map.")]
 153 »       [SerializeField]
154 »       [Header("Metadata")]154 »       [Header("Metadata")]
155 »       private·int·id;155 »       private·int·id;
156 156
157 »       [SerializeField] 
158 »       [Header("Mushroom·Animations")]157 »       [Header("Mushroom·Animations")]
 158 »       [SerializeField]
159 »       private·SpriteAnim·mushroomAnimator;159 »       private·SpriteAnim·mushroomAnimator;
160 160
161 »       [SerializeField]161 »       [SerializeField]
162 »       private·AnimationClip·mushroomIdle;162 »       private·AnimationClip·mushroomIdle;
163 163
164 »       [SerializeField]164 »       [SerializeField]
165 »       private·AnimationClip·mushroomAppear;165 »       private·AnimationClip·mushroomAppear;
166 166
167 »       [SerializeField]167 »       [SerializeField]
168 »       private·AnimationClip·mushroomSteppedOn;168 »       private·AnimationClip·mushroomSteppedOn;
169 169
170 »       [SerializeField] 
171 »       [Header("Spore·Cloud·Animations")]170 »       [Header("Spore·Cloud·Animations")]
 171 »       [SerializeField]
172 »       private·SpriteAnim·sporeCloudAnimator;172 »       private·SpriteAnim·sporeCloudAnimator;
173 173
174 »       [SerializeField]174 »       [SerializeField]
175 »       private·SpriteAnim·sporeCloudMaskAnimator;175 »       private·SpriteAnim·sporeCloudMaskAnimator;
176 176
177 »       [SerializeField]177 »       [SerializeField]
178 »       private·AnimationClip·sporeCloudIdle;178 »       private·AnimationClip·sporeCloudIdle;
179 179
180 »       [SerializeField]180 »       [SerializeField]
181 »       private·AnimationClip·sporeCloudAppear;181 »       private·AnimationClip·sporeCloudAppear;
182 182
183 »       [SerializeField]183 »       [SerializeField]
184 »       private·AnimationClip·sporeCloudDisappear;184 »       private·AnimationClip·sporeCloudDisappear;
185 185
186 »       [SerializeField] 
187 »       [Header("Timings")]186 »       [Header("Timings")]
 187 »       [SerializeField]
188 »       private·float·secondsBetweenSporeReleases·=·17f;188 »       private·float·secondsBetweenSporeReleases·=·17f;
189 189
190 »       [SerializeField]190 »       [SerializeField]
191 »       private·float·secondsSporeIsActive·=·5f;191 »       private·float·secondsSporeIsActive·=·5f;
192 192
193 »       [SerializeField]193 »       [SerializeField]
194 »       private·float·secondsSporeReappearsFor·=·2f;194 »       private·float·secondsSporeReappearsFor·=·2f;
195 195
196 »       [SerializeField]196 »       [SerializeField]
197 »       private·float·secondsSporeFade·=·1f;197 »       private·float·secondsSporeFade·=·1f;
198 198
199 »       [SerializeField] 
200 »       [Header("Audio")]199 »       [Header("Audio")]
 200 »       [SerializeField]
201 »       private·AudioClip·spawnSound;201 »       private·AudioClip·spawnSound;
202 202
203 »       [SerializeField]203 »       [SerializeField]
204 »       private·AudioClip·activateSporeSound;204 »       private·AudioClip·activateSporeSound;
205 205
206 »       private·ContactFilter2D·filter;206 »       private·ContactFilter2D·filter;
207 207
508 B
Assembly-CSharp/MushroomDoorSabotageMinigameMushroom.cs
Ordering differences only
    
Offset 127, 16 lines modifiedOffset 127, 16 lines modified
127 127
128 »       [SerializeField]128 »       [SerializeField]
129 »       private·SpriteRenderer·sprite;129 »       private·SpriteRenderer·sprite;
130 130
131 »       [SerializeField]131 »       [SerializeField]
132 »       private·ParticleSystem·whackedEffect;132 »       private·ParticleSystem·whackedEffect;
133 133
134 »       [SerializeField] 
135 »       [Header("Audio")]134 »       [Header("Audio")]
 135 »       [SerializeField]
136 »       private·AudioClip·mushroomAppearSFX;136 »       private·AudioClip·mushroomAppearSFX;
137 137
138 »       [SerializeField]138 »       [SerializeField]
139 »       private·AudioClip·mushroomDisappearSFX;139 »       private·AudioClip·mushroomDisappearSFX;
140 140
141 »       [SerializeField]141 »       [SerializeField]
142 »       private·AudioClip·mushroomHitSFX;142 »       private·AudioClip·mushroomHitSFX;
7.84 KB
Assembly-CSharp/MushroomMixupSabotageSystem.cs
    
Offset 33, 15 lines modifiedOffset 33, 15 lines modified
33 33
34 »       private·void·PopulateSkinsFromPlayers()34 »       private·void·PopulateSkinsFromPlayers()
35 »       {35 »       {
36 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)36 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
37 »       »       {37 »       »       {
38 »       »       »       if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null))38 »       »       »       if·(!(playerControl·==·null)·&&·playerControl.CurrentOutfit·!=·null·&&·!(playerControl.gameObject·==·null))
39 »       »       »       {39 »       »       »       {
40 »       »       »       »       GameData.PlayerOutfit·currentOutfit·=·playerControl.CurrentOutfit;40 »       »       »       »       NetworkedPlayerInfo.PlayerOutfit·currentOutfit·=·playerControl.CurrentOutfit;
41 »       »       »       »       if·(!this.skinIds.Contains(currentOutfit.SkinId))41 »       »       »       »       if·(!this.skinIds.Contains(currentOutfit.SkinId))
42 »       »       »       »       {42 »       »       »       »       {
43 »       »       »       »       »       this.skinIds.Add(currentOutfit.SkinId);43 »       »       »       »       »       this.skinIds.Add(currentOutfit.SkinId);
44 »       »       »       »       }44 »       »       »       »       }
45 »       »       »       }45 »       »       »       }
46 »       »       }46 »       »       }
47 »       }47 »       }
Offset 50, 15 lines modifiedOffset 50, 15 lines modified
50 »       {50 »       {
51 »       »       if·(GameData.Instance)51 »       »       if·(GameData.Instance)
52 »       »       {52 »       »       {
53 »       »       »       List<byte>·list·=·new·List<byte>();53 »       »       »       List<byte>·list·=·new·List<byte>();
54 »       »       »       foreach·(KeyValuePair<byte,·MushroomMixupSabotageSystem.CondensedOutfit>·keyValuePair·in·this.currentMixups)54 »       »       »       foreach·(KeyValuePair<byte,·MushroomMixupSabotageSystem.CondensedOutfit>·keyValuePair·in·this.currentMixups)
55 »       »       »       {55 »       »       »       {
56 »       »       »       »       byte·key·=·keyValuePair.Key;56 »       »       »       »       byte·key·=·keyValuePair.Key;
57 »       »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(key);57 »       »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(key);
58 »       »       »       »       if·(playerById·==·null·||·playerById.Disconnected·||·playerById.IsDead)58 »       »       »       »       if·(playerById·==·null·||·playerById.Disconnected·||·playerById.IsDead)
59 »       »       »       »       {59 »       »       »       »       {
60 »       »       »       »       »       list.Add(key);60 »       »       »       »       »       list.Add(key);
61 »       »       »       »       }61 »       »       »       »       }
62 »       »       »       }62 »       »       »       }
63 »       »       »       if·(list.Count·>·0)63 »       »       »       if·(list.Count·>·0)
64 »       »       »       {64 »       »       »       {
Offset 154, 30 lines modifiedOffset 154, 30 lines modified
154 »       private·void·UpdatePlayerOutfits()154 »       private·void·UpdatePlayerOutfits()
155 »       {155 »       {
156 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)156 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
157 »       »       {157 »       »       {
158 »       »       »       if·(!(playerControl·==·null)·&&·!playerControl.Data.IsDead·&&·this.currentMixups.ContainsKey(playerControl.PlayerId))158 »       »       »       if·(!(playerControl·==·null)·&&·!playerControl.Data.IsDead·&&·this.currentMixups.ContainsKey(playerControl.PlayerId))
159 »       »       »       {159 »       »       »       {
160 »       »       »       »       MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit·=·this.currentMixups[playerControl.PlayerId];160 »       »       »       »       MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit·=·this.currentMixups[playerControl.PlayerId];
161 »       »       »       »       GameData.PlayerOutfit·playerOutfit·=·this.ConvertToPlayerOutfit(condensedOutfit);161 »       »       »       »       NetworkedPlayerInfo.PlayerOutfit·playerOutfit·=·this.ConvertToPlayerOutfit(condensedOutfit);
162 »       »       »       »       PlayerControl·player·=·playerControl;162 »       »       »       »       PlayerControl·player·=·playerControl;
163 »       »       »       »       playerOutfit.NamePlateId·=·player.Data.DefaultOutfit.NamePlateId;163 »       »       »       »       playerOutfit.NamePlateId·=·player.Data.DefaultOutfit.NamePlateId;
164 »       »       »       »       MushroomMixupPlayerAnimation·mushroomMixupPlayerAnimation·=·Object.Instantiate<MushroomMixupPlayerAnimation>(this.playerAnimationPrefab,·player.transform,·false);164 »       »       »       »       MushroomMixupPlayerAnimation·mushroomMixupPlayerAnimation·=·Object.Instantiate<MushroomMixupPlayerAnimation>(this.playerAnimationPrefab,·player.transform,·false);
165 »       »       »       »       mushroomMixupPlayerAnimation.SetPlayer(player);165 »       »       »       »       mushroomMixupPlayerAnimation.SetPlayer(player);
166 »       »       »       »       mushroomMixupPlayerAnimation.StartAnimation(ShipStatus.Instance.CosmeticsCache.CoPopulateFromOutfit(playerOutfit),·delegate166 »       »       »       »       mushroomMixupPlayerAnimation.StartAnimation(ShipStatus.Instance.CosmeticsCache.CoPopulateFromOutfit(playerOutfit),·delegate
167 »       »       »       »       {167 »       »       »       »       {
168 »       »       »       »       »       player.MixUpOutfit(playerOutfit);168 »       »       »       »       »       player.MixUpOutfit(playerOutfit);
169 »       »       »       »       });169 »       »       »       »       });
170 »       »       »       }170 »       »       »       }
171 »       »       }171 »       »       }
172 »       }172 »       }
173 173
174 »       public·void·Serialize(MessageWriter·writer,·bool·initialState)174 »       public·void·Serialize(MessageWriter·writer,·bool·initialState)
175 »       {175 »       {
176 »       »       if·(this.cachedOutfitsByPlayerId.Count·==·0)176 »       »       if·(this.cachedOutfitsByPlayerId.Count·==·0·&&·this.AllPlayersHaveData())
177 »       »       {177 »       »       {
178 »       »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)178 »       »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
179 »       »       »       {179 »       »       »       {
180 »       »       »       »       this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit;180 »       »       »       »       this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit;
181 »       »       »       }181 »       »       »       }
182 »       »       }182 »       »       }
183 »       »       writer.Write((byte)this.currentState);183 »       »       writer.Write((byte)this.currentState);
Offset 190, 15 lines modifiedOffset 190, 15 lines modified
190 »       »       }190 »       »       }
191 »       »       this.currentState·=·((this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered)·?·MushroomMixupSabotageSystem.State.IdleButMixedUp·:·this.currentState);191 »       »       this.currentState·=·((this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered)·?·MushroomMixupSabotageSystem.State.IdleButMixedUp·:·this.currentState);
192 »       »       this.IsDirty·=·initialState;192 »       »       this.IsDirty·=·initialState;
193 »       }193 »       }
194 194
195 »       public·void·Deserialize(MessageReader·reader,·bool·initialState)195 »       public·void·Deserialize(MessageReader·reader,·bool·initialState)
196 »       {196 »       {
197 »       »       if·(this.cachedOutfitsByPlayerId.Count·==·0)197 »       »       if·(this.cachedOutfitsByPlayerId.Count·==·0·&&·this.AllPlayersHaveData())
198 »       »       {198 »       »       {
199 »       »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)199 »       »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
200 »       »       »       {200 »       »       »       {
201 »       »       »       »       this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit;201 »       »       »       »       this.cachedOutfitsByPlayerId[playerControl.PlayerId]·=·playerControl.Data.DefaultOutfit;
202 »       »       »       }202 »       »       »       }
203 »       »       }203 »       »       }
204 »       »       MushroomMixupSabotageSystem.State·state·=·this.currentState;204 »       »       MushroomMixupSabotageSystem.State·state·=·this.currentState;
Offset 216, 94 lines modifiedOffset 216, 109 lines modified
216 »       »       if·(state·!=·this.currentState·&&·this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered)216 »       »       if·(state·!=·this.currentState·&&·this.currentState·==·MushroomMixupSabotageSystem.State.JustTriggered)
217 »       »       {217 »       »       {
218 »       »       »       this.MushroomMixUp();218 »       »       »       this.MushroomMixUp();
219 »       »       »       this.currentState·=·MushroomMixupSabotageSystem.State.IdleButMixedUp;219 »       »       »       this.currentState·=·MushroomMixupSabotageSystem.State.IdleButMixedUp;
220 »       »       }220 »       »       }
221 »       }221 »       }
222 222
 223 »       private·bool·AllPlayersHaveData()
 224 »       {
 225 »       »       using·(List<PlayerControl>.Enumerator·enumerator·=·PlayerControl.AllPlayerControls.GetEnumerator())
 226 »       »       {
 227 »       »       »       while·(enumerator.MoveNext())
 228 »       »       »       {
 229 »       »       »       »       if·(enumerator.Current.Data·==·null)
 230 »       »       »       »       {
 231 »       »       »       »       »       return·false;
 232 »       »       »       »       }
 233 »       »       »       }
 234 »       »       }
 235 »       »       return·true;
 236 »       }
 237
223 »       private·MushroomMixupSabotageSystem.CondensedOutfit·GenerateRandomOutfit(int·playerId)238 »       private·MushroomMixupSabotageSystem.CondensedOutfit·GenerateRandomOutfit(int·playerId)
224 »       {239 »       {
225 »       »       List<byte>·list·=·new·List<byte>(this.cachedOutfitsByPlayerId.Keys);240 »       »       List<byte>·list·=·new·List<byte>(this.cachedOutfitsByPlayerId.Keys);
226 »       »       list.Remove((byte)playerId);241 »       »       list.Remove((byte)playerId);
227 »       »       return·new·MushroomMixupSabotageSystem.CondensedOutfit242 »       »       return·new·MushroomMixupSabotageSystem.CondensedOutfit
228 »       »       {243 »       »       {
229 »       »       »       ColorPlayerId·=·list.Random<byte>(),244 »       »       »       ColorPlayerId·=·list.Random<byte>(),
230 »       »       »       HatIndex·=·((Random.Range(0f,·1f)·<·this.hatEmptyChance)·?·byte.MaxValue·:·((byte)this.hatIds.RandomIdx<string>())),245 »       »       »       HatIndex·=·((Random.Range(0f,·1f)·<·this.hatEmptyChance)·?·byte.MaxValue·:·((byte)this.hatIds.RandomIdx<string>())),
231 »       »       »       VisorIndex·=·((Random.Range(0f,·1f)·<·this.visorEmptyChance)·?·byte.MaxValue·:·((byte)this.visorIds.RandomIdx<string>())),246 »       »       »       VisorIndex·=·((Random.Range(0f,·1f)·<·this.visorEmptyChance)·?·byte.MaxValue·:·((byte)this.visorIds.RandomIdx<string>())),
232 »       »       »       SkinIndex·=·((Random.Range(0f,·1f)·<·this.skinEmptyChance)·?·byte.MaxValue·:·((byte)this.skinIds.RandomIdx<string>())),247 »       »       »       SkinIndex·=·((Random.Range(0f,·1f)·<·this.skinEmptyChance)·?·byte.MaxValue·:·((byte)this.skinIds.RandomIdx<string>())),
233 »       »       »       PetIndex·=·((Random.Range(0f,·1f)·<·this.petEmptyChance)·?·byte.MaxValue·:·((byte)this.petIds.RandomIdx<string>()))248 »       »       »       PetIndex·=·((Random.Range(0f,·1f)·<·this.petEmptyChance)·?·byte.MaxValue·:·((byte)this.petIds.RandomIdx<string>()))
234 »       »       };249 »       »       };
235 »       }250 »       }
236 251
237 »       private·GameData.PlayerOutfit·ConvertToPlayerOutfit(MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit)252 »       private·NetworkedPlayerInfo.PlayerOutfit·ConvertToPlayerOutfit(MushroomMixupSabotageSystem.CondensedOutfit·condensedOutfit)
238 »       {253 »       {
239 »       »       return·new·GameData.PlayerOutfit254 »       »       return·new·NetworkedPlayerInfo.PlayerOutfit
240 »       »       {255 »       »       {
241 »       »       »       ColorId·=·(this.cachedOutfitsByPlayerId.ContainsKey(condensedOutfit.ColorPlayerId)·?·this.cachedOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId·:·this.deadAndDcPlayerOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId),256 »       »       »       ColorId·=·(this.cachedOutfitsByPlayerId.ContainsKey(condensedOutfit.ColorPlayerId)·?·this.cachedOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId·:·this.deadAndDcPlayerOutfitsByPlayerId[condensedOutfit.ColorPlayerId].ColorId),
242 »       »       »       HatId·=·(((int)condensedOutfit.HatIndex·>=·this.hatIds.Length)·?·"hat_NoHat"·:·this.hatIds[(int)condensedOutfit.HatIndex]),257 »       »       »       HatId·=·(((int)condensedOutfit.HatIndex·>=·this.hatIds.Length)·?·"hat_NoHat"·:·this.hatIds[(int)condensedOutfit.HatIndex]),
243 »       »       »       SkinId·=·(((int)condensedOutfit.SkinIndex·>=·this.skinIds.Count)·?·"skin_None"·:·this.skinIds[(int)condensedOutfit.SkinIndex]),258 »       »       »       SkinId·=·(((int)condensedOutfit.SkinIndex·>=·this.skinIds.Count)·?·"skin_None"·:·this.skinIds[(int)condensedOutfit.SkinIndex]),
244 »       »       »       VisorId·=·(((int)condensedOutfit.VisorIndex·>=·this.visorIds.Length)·?·"visor_EmptyVisor"·:·this.visorIds[(int)condensedOutfit.VisorIndex]),259 »       »       »       VisorId·=·(((int)condensedOutfit.VisorIndex·>=·this.visorIds.Length)·?·"visor_EmptyVisor"·:·this.visorIds[(int)condensedOutfit.VisorIndex]),
245 »       »       »       PetId·=·(((int)condensedOutfit.PetIndex·>=·this.petIds.Length)·?·"pet_EmptyPet"·:·this.petIds[(int)condensedOutfit.PetIndex])260 »       »       »       PetId·=·(((int)condensedOutfit.PetIndex·>=·this.petIds.Length)·?·"pet_EmptyPet"·:·this.petIds[(int)condensedOutfit.PetIndex])
246 »       »       };261 »       »       };
247 »       }262 »       }
248 263
Max diff block lines reached; 1983/7938 bytes (24.98%) of diff not shown.
850 B
Assembly-CSharp/MushroomWallDoor.cs
    
Offset 24, 14 lines modifiedOffset 24, 18 lines modified
24 »       »       if·(this.open·==·open)24 »       »       if·(this.open·==·open)
25 »       »       {25 »       »       {
26 »       »       »       return;26 »       »       »       return;
27 »       »       }27 »       »       }
28 »       »       this.open·=·open;28 »       »       this.open·=·open;
29 »       »       this.wallCollider.isTrigger·=·open;29 »       »       this.wallCollider.isTrigger·=·open;
30 »       »       this.shadowColl.enabled·=·!open;30 »       »       this.shadowColl.enabled·=·!open;
 31 »       »       if·(this.bottomColl·!=·null)
 32 »       »       {
 33 »       »       »       this.bottomColl.enabled·=·!open;
 34 »       »       }
31 »       »       foreach·(MushroomWallMushroom·mushroomWallMushroom·in·this.mushrooms)35 »       »       foreach·(MushroomWallMushroom·mushroomWallMushroom·in·this.mushrooms)
32 »       »       {36 »       »       {
33 »       »       »       if·(open)37 »       »       »       if·(open)
34 »       »       »       {38 »       »       »       {
35 »       »       »       »       mushroomWallMushroom.Hide();39 »       »       »       »       mushroomWallMushroom.Hide();
36 »       »       »       }40 »       »       »       }
37 »       »       »       else41 »       »       »       else
Offset 92, 14 lines modifiedOffset 96, 17 lines modified
92 »       [SerializeField]96 »       [SerializeField]
93 »       private·BoxCollider2D·wallCollider;97 »       private·BoxCollider2D·wallCollider;
94 98
95 »       [SerializeField]99 »       [SerializeField]
96 »       private·Collider2D·shadowColl;100 »       private·Collider2D·shadowColl;
97 101
98 »       [SerializeField]102 »       [SerializeField]
 103 »       private·Collider2D·bottomColl;
 104
 105 »       [SerializeField]
99 »       private·MushroomWallMushroom[]·mushrooms;106 »       private·MushroomWallMushroom[]·mushrooms;
100 107
101 »       [SerializeField]108 »       [SerializeField]
102 »       private·AudioClip·openSound;109 »       private·AudioClip·openSound;
103 110
104 »       [SerializeField]111 »       [SerializeField]
105 »       private·AudioClip·closeSound;112 »       private·AudioClip·closeSound;
963 B
Assembly-CSharp/NormalPlayerTask.cs
Ordering differences only
    
Offset 631, 28 lines modifiedOffset 631, 28 lines modified
631 631
632 »       public·float·TaskTimer;632 »       public·float·TaskTimer;
633 633
634 »       public·byte[]·Data;634 »       public·byte[]·Data;
635 635
636 »       public·ArrowBehaviour·Arrow;636 »       public·ArrowBehaviour·Arrow;
637 637
638 »       [Tooltip("To·have·multiple·texts·on·multistage·tasks")] 
639 »       [SerializeField]638 »       [SerializeField]
 639 »       [Tooltip("To·have·multiple·texts·on·multistage·tasks")]
640 »       private·bool·useMultipleText;640 »       private·bool·useMultipleText;
641 641
642 »       [SerializeField] 
643 »       [Tooltip("For·tasks·that·need·a·number·of·steps·completed·before·stage·2")]642 »       [Tooltip("For·tasks·that·need·a·number·of·steps·completed·before·stage·2")]
 643 »       [SerializeField]
644 »       private·int·maxNumStepsStage1;644 »       private·int·maxNumStepsStage1;
645 645
646 »       [Tooltip("Used·only·if·useMultipleText·is·selected")] 
647 »       [SerializeField]646 »       [SerializeField]
 647 »       [Tooltip("Used·only·if·useMultipleText·is·selected")]
648 »       private·StringNames·textStage1;648 »       private·StringNames·textStage1;
649 649
650 »       [Tooltip("Used·only·if·useMultipleText·is·selected")] 
651 »       [SerializeField]650 »       [SerializeField]
 651 »       [Tooltip("Used·only·if·useMultipleText·is·selected")]
652 »       private·StringNames·textStage2;652 »       private·StringNames·textStage2;
653 653
654 »       protected·bool·arrowSuspended;654 »       protected·bool·arrowSuspended;
655 655
656 »       public·enum·TaskLength656 »       public·enum·TaskLength
657 »       {657 »       {
658 »       »       None,658 »       »       None,
6.97 KB
Assembly-CSharp/NotificationPopper.cs
    
Offset 1, 56 lines modifiedOffset 1, 162 lines modified
1 using·System;1 using·System;
2 using·System.Text; 
3 using·TMPro;2 using·System.Collections.Generic;
 3 using·AmongUs.GameOptions;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·NotificationPopper·:·MonoBehaviour6 public·class·NotificationPopper·:·MonoBehaviour
7 {7 {
8 »       public·void·Update()8 »       private·void·Awake()
9 »       {9 »       {
10 »       »       if·(this.alphaTimer·>·0f)10 »       »       this.activeMessages·=·new·List<LobbyNotificationMessage>();
 11 »       }
 12
 13 »       private·void·Update()
 14 »       {
 15 »       }
 16
 17 »       public·void·AddDisconnectMessage(string·item)
 18 »       {
 19 »       »       LobbyNotificationMessage·newMessage·=·Object.Instantiate<LobbyNotificationMessage>(this.notificationMessageOrigin,·Vector3.zero,·Quaternion.identity,·base.transform);
 20 »       »       newMessage.transform.localPosition·=·new·Vector3(0f,·0f,·-2f);
 21 »       »       newMessage.SetUp(item,·this.playerDisconnectSprite,·this.disconnectColor,·delegate
 22 »       »       {
 23 »       »       »       this.OnMessageDestroy(newMessage);
 24 »       »       });
 25 »       »       SoundManager.Instance.PlaySound(this.playerDisconnectSound,·false,·1f,·null);
 26 »       »       this.ShiftMessages();
 27 »       »       this.AddMessageToQueue(newMessage);
 28 »       }
 29
 30 »       public·void·AddSettingsChangeMessage(StringNames·key,·string·value,·bool·playSound·=·true,·RoleTypes·associatedRole·=·RoleTypes.Crewmate)
 31 »       {
 32 »       »       string·text·=·string.Empty;
 33 »       »       if·(associatedRole·!=·RoleTypes.Crewmate)
11 »       »       {34 »       »       {
12 »       »       »       if·(this.mainCamera·==·null)35 »       »       »       string·text2·=·(RoleManager.IsImpostorRole(associatedRole)·?·Palette.ImpostorRed.ToTextColor()·:·Palette.CrewmateSettingChangeText.ToTextColor());
 36 »       »       »       text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyChangeSettingNotification,·new·object[]
13 »       »       »       {37 »       »       »       {
14 »       »       »       »       this.mainCamera·=·Camera.main;38 »       »       »       »       string.Concat(new·string[]
 39 »       »       »       »       {
 40 »       »       »       »       »       "<sprite·name=\"",
 41 »       »       »       »       »       associatedRole.ToString(),
 42 »       »       »       »       »       "Role\">·<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">",
 43 »       »       »       »       »       text2,
 44 »       »       »       »       »       DestroyableSingleton<TranslationController>.Instance.GetString(key,·Array.Empty<object>()),
 45 »       »       »       »       »       "</color></font>"
 46 »       »       »       »       }),
 47 »       »       »       »       "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·value·+·"</font>"
 48 »       »       »       });
15 »       »       »       }49 »       »       }
16 »       »       »       float·num·=·this.mainCamera.orthographicSize·*·this.mainCamera.aspect; 
17 »       »       »       float·y·=·DestroyableSingleton<HudManager>.Instance.GameSettings.bounds.size.y; 
18 »       »       »       Transform·transform·=·DestroyableSingleton<HudManager>.Instance.GameSettings.transform; 
19 »       »       »       base.transform.localPosition·=·new·Vector3(-num·+·0.1f,·transform.localPosition.y·-·y,·this.zPos); 
20 »       »       »       this.alphaTimer·-=·Time.deltaTime; 
21 »       »       »       this.textColor.a·=·Mathf.Clamp(this.alphaTimer·/·this.FadeDuration,·0f,·1f); 
22 »       »       »       this.TextArea.color·=·this.textColor; 
23 »       »       »       if·(this.alphaTimer·<=·0f)50 »       »       else
 51 »       »       {
 52 »       »       »       text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyChangeSettingNotification,·new·object[]
 53 »       »       »       {
 54 »       »       »       »       "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·DestroyableSingleton<TranslationController>.Instance.GetString(key,·Array.Empty<object>())·+·"</font>",
 55 »       »       »       »       "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·value·+·"</font>"
 56 »       »       »       });
 57 »       »       }
 58 »       »       this.SettingsChangeMessageLogic(key,·text,·playSound);
 59 »       }
 60
 61 »       public·void·AddRoleSettingsChangeMessage(StringNames·key,·int·roleCount,·int·roleChance,·RoleTeamTypes·teamType,·bool·playSound·=·true)
 62 »       {
 63 »       »       string·text·=·string.Empty;
 64 »       »       string·text2·=·((teamType·==·RoleTeamTypes.Crewmate)·?·Palette.CrewmateSettingChangeText.ToTextColor()·:·Palette.ImpostorRed.ToTextColor());
 65 »       »       text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LobbyChangeSettingNotificationRole,·new·object[]
 66 »       »       {
 67 »       »       »       string.Concat(new·string[]
 68 »       »       »       {
 69 »       »       »       »       "<sprite·name=\"",
 70 »       »       »       »       key.ToString(),
 71 »       »       »       »       "\">·<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">",
 72 »       »       »       »       text2,
 73 »       »       »       »       DestroyableSingleton<TranslationController>.Instance.GetString(key,·Array.Empty<object>()),
 74 »       »       »       »       "</color></font>"
 75 »       »       »       }),
 76 »       »       »       "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·roleCount.ToString()·+·"</font>",
 77 »       »       »       "<font=\"Barlow-Black·SDF\"·material=\"Barlow-Black·Outline\">"·+·roleChance.ToString()·+·"%"
 78 »       »       });
 79 »       »       this.SettingsChangeMessageLogic(key,·text,·playSound);
 80 »       }
 81
 82 »       private·void·SettingsChangeMessageLogic(StringNames·key,·string·item,·bool·playSound)
 83 »       {
 84 »       »       if·(this.lastMessageKey·==·(int)key·&&·this.activeMessages.Count·>·0)
 85 »       »       {
 86 »       »       »       this.activeMessages[this.activeMessages.Count·-·1].UpdateMessage(item);
 87 »       »       }
 88 »       »       else
 89 »       »       {
 90 »       »       »       this.lastMessageKey·=·(int)key;
 91 »       »       »       LobbyNotificationMessage·newMessage·=·Object.Instantiate<LobbyNotificationMessage>(this.notificationMessageOrigin,·Vector3.zero,·Quaternion.identity,·base.transform);
 92 »       »       »       newMessage.transform.localPosition·=·new·Vector3(0f,·0f,·-2f);
 93 »       »       »       newMessage.SetUp(item,·this.settingsChangeSprite,·this.settingsChangeColor,·delegate
24 »       »       »       {94 »       »       »       {
25 »       »       »       »       this.builder.Clear(); 
26 »       »       »       »       this.TextArea.text·=·string.Empty;95 »       »       »       »       this.OnMessageDestroy(newMessage);
 96 »       »       »       });
 97 »       »       »       this.ShiftMessages();
 98 »       »       »       this.AddMessageToQueue(newMessage);
27 »       »       »       }99 »       »       }
 100 »       »       if·(playSound)
 101 »       »       {
 102 »       »       »       SoundManager.Instance.PlaySoundImmediate(this.settingsChangeSound,·false,·1f,·1f,·null);
 103 »       »       }
 104 »       }
 105
 106 »       private·void·AddMessageToQueue(LobbyNotificationMessage·newMessage)
 107 »       {
 108 »       »       while·(this.activeMessages.Count·>=·this.maxMessages)
 109 »       »       {
 110 »       »       »       Object.Destroy(this.activeMessages[0].gameObject);
 111 »       »       »       this.activeMessages.RemoveAt(0);
 112 »       »       }
 113 »       »       this.activeMessages.Add(newMessage);
 114 »       }
 115
 116 »       private·void·ShiftMessages()
 117 »       {
 118 »       »       foreach·(LobbyNotificationMessage·lobbyNotificationMessage·in·this.activeMessages)
Max diff block lines reached; 1429/7059 bytes (20.24%) of diff not shown.
8.42 KB
Assembly-CSharp/NumberOption.cs
    
Offset 1, 160 lines modifiedOffset 1, 146 lines modified
1 using·System;1 using·System;
2 using·AmongUs.GameOptions;2 using·AmongUs.GameOptions;
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·NumberOption·:·OptionBehaviour6 public·class·NumberOption·:·OptionBehaviour
7 {7 {
8 »       public·void·OnEnable()8 »       public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer)
9 »       {9 »       {
 10 »       »       base.SetUpFromData(data,·maskLayer);
 11 »       »       if·(data.Type·==·OptionTypes.Float)
10 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); 
11 »       »       this.FixedUpdate(); 
12 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; 
13 »       »       StringNames·title·=·this.Title; 
14 »       »       if·(title·<=·StringNames.ImpostorFlashlightSize) 
15 »       »       {12 »       »       {
16 »       »       »       switch·(title)13 »       »       »       FloatGameSetting·floatGameSetting·=·data·as·FloatGameSetting;
 14 »       »       »       if·(floatGameSetting·==·null)
17 »       »       »       {15 »       »       »       {
18 »       »       »       case·StringNames.GameNumImpostors: 
19 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumImpostors); 
20 »       »       »       »       return; 
21 »       »       »       case·StringNames.GameNumMeetings: 
22 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumEmergencyMeetings); 
23 »       »       »       »       return; 
24 »       »       »       case·StringNames.GameDiscussTime: 
25 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.DiscussionTime); 
26 »       »       »       »       return; 
27 »       »       »       case·StringNames.GameVotingTime: 
28 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.VotingTime); 
29 »       »       »       »       return; 
30 »       »       »       case·StringNames.GamePlayerSpeed: 
31 »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.PlayerSpeedMod); 
32 »       »       »       »       return; 
33 »       »       »       case·StringNames.GameCrewLight: 
34 »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.CrewLightMod); 
35 »       »       »       »       return; 
36 »       »       »       case·StringNames.GameImpostorLight: 
37 »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.ImpostorLightMod); 
38 »       »       »       »       return;16 »       »       »       »       return;
39 »       »       »       case·StringNames.GameKillCooldown: 
40 »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.KillCooldown); 
41 »       »       »       »       return; 
42 »       »       »       case·StringNames.GameKillDistance: 
43 »       »       »       »       break; 
44 »       »       »       case·StringNames.GameCommonTasks: 
45 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumCommonTasks); 
46 »       »       »       »       return; 
47 »       »       »       case·StringNames.GameLongTasks: 
48 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumLongTasks); 
49 »       »       »       »       return; 
50 »       »       »       case·StringNames.GameShortTasks: 
51 »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.NumShortTasks); 
52 »       »       »       »       return; 
53 »       »       »       default: 
54 »       »       »       »       if·(title·==·StringNames.GameEmergencyCooldown) 
55 »       »       »       »       { 
56 »       »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.EmergencyCooldown); 
57 »       »       »       »       »       return; 
58 »       »       »       »       } 
59 »       »       »       »       switch·(title) 
60 »       »       »       »       { 
61 »       »       »       »       case·StringNames.MaxVentUses: 
62 »       »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.CrewmateVentUses); 
63 »       »       »       »       »       return; 
64 »       »       »       »       case·StringNames.MaxTimeInVent: 
65 »       »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.CrewmateTimeInVent); 
66 »       »       »       »       »       return; 
67 »       »       »       »       case·StringNames.MinCrewmatesForVitals: 
68 »       »       »       »       »       this.Value·=·(float)currentGameOptions.GetInt(Int32OptionNames.CrewmatesRemainingForVitals); 
69 »       »       »       »       »       return; 
70 »       »       »       »       case·StringNames.EscapeTime: 
71 »       »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.EscapeTime); 
72 »       »       »       »       »       return; 
73 »       »       »       »       case·StringNames.AllTasksComplete: 
74 »       »       »       »       case·StringNames.EscapePrompt: 
75 »       »       »       »       »       break; 
76 »       »       »       »       case·StringNames.CrewmateFlashlightSize: 
77 »       »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.CrewmateFlashlightSize); 
78 »       »       »       »       »       return; 
79 »       »       »       »       case·StringNames.ImpostorFlashlightSize: 
80 »       »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.ImpostorFlashlightSize); 
81 »       »       »       »       »       return; 
82 »       »       »       »       default: 
83 »       »       »       »       »       return; 
84 »       »       »       »       } 
85 »       »       »       »       break; 
86 »       »       »       }17 »       »       »       }
 18 »       »       »       this.Title·=·floatGameSetting.Title;
 19 »       »       »       this.Value·=·floatGameSetting.Value;
 20 »       »       »       this.Increment·=·floatGameSetting.Increment;
 21 »       »       »       this.ValidRange·=·floatGameSetting.ValidRange;
 22 »       »       »       this.FormatString·=·floatGameSetting.FormatString;
 23 »       »       »       this.ZeroIsInfinity·=·floatGameSetting.ZeroIsInfinity;
 24 »       »       »       this.SuffixType·=·floatGameSetting.SuffixType;
 25 »       »       »       this.floatOptionName·=·floatGameSetting.OptionName;
 26 »       »       »       return;
87 »       »       }27 »       »       }
88 »       »       else28 »       »       else
89 »       »       {29 »       »       {
 30 »       »       »       if·(data.Type·!=·OptionTypes.Int)
90 »       »       »       if·(title·==·StringNames.FinalEscapeTime) 
91 »       »       »       { 
92 »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.FinalEscapeTime); 
93 »       »       »       »       return; 
94 »       »       »       } 
95 »       »       »       if·(title·==·StringNames.SeekerFinalSpeed) 
96 »       »       »       {31 »       »       »       {
97 »       »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.SeekerFinalSpeed);32 »       »       »       »       Debug.LogError("Could·not·set·up·NumberOption·for·"·+·data.Title.ToString());
98 »       »       »       »       return;33 »       »       »       »       return;
99 »       »       »       }34 »       »       »       }
100 »       »       »       if·(title·!=·StringNames.MaxPingTime)35 »       »       »       IntGameSetting·intGameSetting·=·data·as·IntGameSetting;
 36 »       »       »       if·(intGameSetting·==·null)
101 »       »       »       {37 »       »       »       {
102 »       »       »       »       return;38 »       »       »       »       return;
103 »       »       »       }39 »       »       »       }
104 »       »       »       this.Value·=·currentGameOptions.GetFloat(FloatOptionNames.MaxPingTime);40 »       »       »       this.Title·=·intGameSetting.Title;
 41 »       »       »       this.Value·=·(float)intGameSetting.Value;
 42 »       »       »       this.Increment·=·(float)intGameSetting.Increment;
 43 »       »       »       this.ValidRange·=·new·FloatRange((float)intGameSetting.ValidRange.min,·(float)intGameSetting.ValidRange.max);
 44 »       »       »       this.FormatString·=·intGameSetting.FormatString;
 45 »       »       »       this.ZeroIsInfinity·=·intGameSetting.ZeroIsInfinity;
 46 »       »       »       this.SuffixType·=·intGameSetting.SuffixType;
 47 »       »       »       this.intOptionName·=·intGameSetting.OptionName;
 48 »       »       »       return;
105 »       »       }49 »       »       }
Max diff block lines reached; 3345/8563 bytes (39.06%) of diff not shown.
620 B
Assembly-CSharp/OpenDoorConsole.cs
    
Offset 29, 15 lines modifiedOffset 29, 15 lines modified
29 29
30 »       public·void·Awake()30 »       public·void·Awake()
31 »       {31 »       {
32 »       »       this.myDoor·=·base.GetComponent<OpenableDoor>();32 »       »       this.myDoor·=·base.GetComponent<OpenableDoor>();
33 »       »       this.image·=·base.GetComponent<SpriteRenderer>();33 »       »       this.image·=·base.GetComponent<SpriteRenderer>();
34 »       }34 »       }
35 35
36 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)36 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
37 »       {37 »       {
38 »       »       float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position);38 »       »       float·num·=·Vector2.Distance(pc.Object.GetTruePosition(),·base.transform.position);
39 »       »       couldUse·=·!pc.IsDead·&&·!this.myDoor.IsOpen;39 »       »       couldUse·=·!pc.IsDead·&&·!this.myDoor.IsOpen;
40 »       »       canUse·=·couldUse·&&·num·<=·this.UsableDistance;40 »       »       canUse·=·couldUse·&&·num·<=·this.UsableDistance;
41 »       »       return·num;41 »       »       return·num;
42 »       }42 »       }
43 43
2.23 KB
Assembly-CSharp/OptionBehaviour.cs
    
Offset 1, 12 lines modifiedOffset 1, 22 lines modified
1 using·System;1 using·System;
 2 using·AmongUs.GameOptions;
 3 using·TMPro;
2 using·UnityEngine;4 using·UnityEngine;
3 5
4 public·abstract·class·OptionBehaviour·:·MonoBehaviour6 public·abstract·class·OptionBehaviour·:·MonoBehaviour
5 {7 {
 8 »       public·BaseGameSetting·Data
 9 »       {
 10 »       »       get
 11 »       »       {
 12 »       »       »       return·this.data;
 13 »       »       }
 14 »       }
 15
6 »       public·virtual·float·GetFloat()16 »       public·virtual·float·GetFloat()
7 »       {17 »       {
8 »       »       throw·new·NotImplementedException();18 »       »       throw·new·NotImplementedException();
9 »       }19 »       }
10 20
11 »       public·virtual·int·GetInt()21 »       public·virtual·int·GetInt()
12 »       {22 »       {
Offset 16, 18 lines modifiedOffset 26, 65 lines modified
16 »       public·virtual·bool·GetBool()26 »       public·virtual·bool·GetBool()
17 »       {27 »       {
18 »       »       throw·new·NotImplementedException();28 »       »       throw·new·NotImplementedException();
19 »       }29 »       }
20 30
21 »       public·void·SetAsPlayer()31 »       public·void·SetAsPlayer()
22 »       {32 »       {
 33 »       »       if·(this.buttons·==·null·||·this.buttons.Length·==·0)
 34 »       »       {
23 »       »       PassiveButton[]·componentsInChildren·=·base.GetComponentsInChildren<PassiveButton>();35 »       »       »       this.buttons·=·base.GetComponentsInChildren<PassiveButton>();
 36 »       »       }
 37 »       »       for·(int·i·=·0;·i·<·this.buttons.Length;·i++)
 38 »       »       {
 39 »       »       »       this.buttons[i].gameObject.SetActive(false);
 40 »       »       }
 41 »       }
 42
 43 »       public·void·SetClickMask(Collider2D·clickMask)
 44 »       {
 45 »       »       if·(this.buttons·==·null·||·this.buttons.Length·==·0)
 46 »       »       {
 47 »       »       »       this.buttons·=·base.GetComponentsInChildren<PassiveButton>();
 48 »       »       }
 49 »       »       for·(int·i·=·0;·i·<·this.buttons.Length;·i++)
 50 »       »       {
 51 »       »       »       this.buttons[i].ClickMask·=·clickMask;
 52 »       »       }
 53 »       }
 54
 55 »       public·virtual·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer)
 56 »       {
 57 »       »       this.data·=·data;
 58 »       »       SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(true);
24 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)59 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)
25 »       »       {60 »       »       {
26 »       »       »       componentsInChildren[i].gameObject.SetActive(false);61 »       »       »       componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·maskLayer);
 62 »       »       }
 63 »       »       foreach·(TextMeshPro·textMeshPro·in·base.GetComponentsInChildren<TextMeshPro>(true))
 64 »       »       {
 65 »       »       »       textMeshPro.fontMaterial.SetFloat("_StencilComp",·3f);
 66 »       »       »       textMeshPro.fontMaterial.SetFloat("_Stencil",·(float)maskLayer);
27 »       »       }67 »       »       }
28 »       }68 »       }
29 69
 70 »       public·virtual·void·Initialize()
 71 »       {
 72 »       }
 73
 74 »       public·string·GetValueString(float·value)
 75 »       {
 76 »       »       return·this.data.GetValueString(value);
 77 »       }
 78
 79 »       public·SpriteRenderer·LabelBackground;
 80
30 »       public·StringNames·Title;81 »       public·StringNames·Title;
31 82
32 »       public·Action<OptionBehaviour>·OnValueChanged;83 »       public·Action<OptionBehaviour>·OnValueChanged;
 84
 85 »       public·RoleTypes·AssociatedRole;
 86
 87 »       protected·BaseGameSetting·data;
 88
 89 »       private·PassiveButton[]·buttons;
33 }90 }
486 B
Assembly-CSharp/OptionsConsole.cs
    
Offset 23, 15 lines modifiedOffset 23, 15 lines modified
23 »       {23 »       {
24 »       »       get24 »       »       get
25 »       »       {25 »       »       {
26 »       »       »       return·0f;26 »       »       »       return·0f;
27 »       »       }27 »       »       }
28 »       }28 »       }
29 29
30 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)30 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
31 »       {31 »       {
32 »       »       float·num·=·float.MaxValue;32 »       »       float·num·=·float.MaxValue;
33 »       »       PlayerControl·@object·=·pc.Object;33 »       »       PlayerControl·@object·=·pc.Object;
34 »       »       couldUse·=·@object.CanMove;34 »       »       couldUse·=·@object.CanMove;
35 »       »       if·(this.HostOnly)35 »       »       if·(this.HostOnly)
36 »       »       {36 »       »       {
37 »       »       »       couldUse·&=·AmongUsClient.Instance.AmHost;37 »       »       »       couldUse·&=·AmongUsClient.Instance.AmHost;
1.3 KB
Assembly-CSharp/OptionsMenuBehaviour.cs
    
Offset 62, 14 lines modifiedOffset 62, 19 lines modified
62 »       »       »       »       this.ControllerSelectable.Add(uiElement);62 »       »       »       »       this.ControllerSelectable.Add(uiElement);
63 »       »       »       }63 »       »       »       }
64 »       »       }64 »       »       }
65 »       }65 »       }
66 66
67 »       private·void·OnDisable()67 »       private·void·OnDisable()
68 »       {68 »       {
 69 »       »       PassiveButton·menuButton·=·this.MenuButton;
 70 »       »       if·(menuButton·!=·null)
 71 »       »       {
 72 »       »       »       menuButton.SelectButton(false);
 73 »       »       }
69 »       »       DataManager.Settings.Save();74 »       »       DataManager.Settings.Save();
70 »       }75 »       }
71 76
72 »       public·void·OnDestroy()77 »       public·void·OnDestroy()
73 »       {78 »       {
74 »       »       if·(DestroyableSingleton<TranslationController>.InstanceExists)79 »       »       if·(DestroyableSingleton<TranslationController>.InstanceExists)
75 »       »       {80 »       »       {
Offset 102, 14 lines modifiedOffset 107, 19 lines modified
102 »       »       if·(Minigame.Instance·!=·null)107 »       »       if·(Minigame.Instance·!=·null)
103 »       »       {108 »       »       {
104 »       »       »       Minigame.Instance.Close();109 »       »       »       Minigame.Instance.Close();
105 »       »       }110 »       »       }
106 »       »       this.OpenTabGroup(0);111 »       »       this.OpenTabGroup(0);
107 »       »       this.UpdateButtons();112 »       »       this.UpdateButtons();
108 »       »       base.gameObject.SetActive(true);113 »       »       base.gameObject.SetActive(true);
 114 »       »       PassiveButton·menuButton·=·this.MenuButton;
 115 »       »       if·(menuButton·!=·null)
 116 »       »       {
 117 »       »       »       menuButton.SelectButton(true);
 118 »       »       }
109 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)119 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
110 »       »       {120 »       »       {
111 »       »       »       ConsoleJoystick.SetMode_MenuAdditive();121 »       »       »       ConsoleJoystick.SetMode_MenuAdditive();
112 »       »       }122 »       »       }
113 »       »       if·(!this.grabbedControllerButtons)123 »       »       if·(!this.grabbedControllerButtons)
114 »       »       {124 »       »       {
115 »       »       »       this.grabbedControllerButtons·=·true;125 »       »       »       this.grabbedControllerButtons·=·true;
Offset 272, 14 lines modifiedOffset 282, 16 lines modified
272 282
273 »       public·BugReportPopup·bugReportPopup;283 »       public·BugReportPopup·bugReportPopup;
274 284
275 »       public·bool·Toggle·=·true;285 »       public·bool·Toggle·=·true;
276 286
277 »       public·TabGroup[]·Tabs;287 »       public·TabGroup[]·Tabs;
278 288
 289 »       public·PassiveButton·MenuButton;
 290
279 »       private·bool·grabbedControllerButtons;291 »       private·bool·grabbedControllerButtons;
280 292
281 »       [Header("Console·Controller·Navigation")]293 »       [Header("Console·Controller·Navigation")]
282 »       public·UiElement·BackButton;294 »       public·UiElement·BackButton;
283 295
284 »       public·UiElement·DefaultButtonSelected;296 »       public·UiElement·DefaultButtonSelected;
285 297
8.4 KB
Assembly-CSharp/OverlayKillAnimation.cs
    
Offset 1, 53 lines modifiedOffset 1, 65 lines modified
1 using·System;1 using·System;
2 using·System.Collections;2 using·System.Collections;
3 using·System.Collections.Generic;3 using·System.Collections.Generic;
4 using·PowerTools;4 using·PowerTools;
5 using·UnityEngine;5 using·UnityEngine;
 6 using·UnityEngine.AddressableAssets;
6 7
7 public·class·OverlayKillAnimation·:·OverlayAnimation8 public·class·OverlayKillAnimation·:·OverlayAnimation
8 {9 {
9 »       public·virtual·void·Initialize(GameData.PlayerInfo·kInfo,·GameData.PlayerInfo·vInfo)10 »       public·bool·LeftFacingVictim
10 »       {11 »       {
 12 »       »       get
 13 »       »       {
 14 »       »       »       return·this.leftFacingVictim;
 15 »       »       }
 16 »       }
 17
 18 »       public·virtual·void·Initialize(KillOverlayInitData·initData)
 19 »       {
 20 »       »       this.initData·=·initData;
11 »       »       if·(this.killerParts)21 »       »       if·(this.killerParts)
12 »       »       {22 »       »       {
13 »       »       »       PlayerControl·playerControl·=·PlayerControl.AllPlayerControls.Find((PlayerControl·p)·=>·p.PlayerId·==·kInfo.PlayerId); 
14 »       »       »       GameData.PlayerOutfit·killerOutfit·=·playerControl.CurrentOutfit; 
15 »       »       »       this.killerParts.SetBodyType(playerControl.BodyType);23 »       »       »       this.killerParts.SetBodyType(initData.killerBodyType);
16 »       »       »       this.killerParts.UpdateFromPlayerData(kInfo,·playerControl.CurrentOutfitType,·PlayerMaterial.MaskType.None,·false,·delegate24 »       »       »       this.killerParts.UpdateFromPlayerOutfit(initData.killerOutfit,·PlayerMaterial.MaskType.None,·false,·false,·delegate
17 »       »       »       {25 »       »       »       {
18 »       »       »       »       this.LoadKillerSkin(killerOutfit);26 »       »       »       »       this.LoadKillerSkin(initData.killerOutfit);
19 »       »       »       },·false);27 »       »       »       },·false);
20 »       »       »       this.killerParts.ToggleName(false);28 »       »       »       this.killerParts.ToggleName(false);
21 »       »       »       this.LoadKillerPet(killerOutfit);29 »       »       »       this.LoadKillerPet(initData.killerOutfit);
22 »       »       }30 »       »       }
23 »       »       if·(vInfo·!=·null·&&·this.victimParts)31 »       »       if·(initData.victimOutfit·!=·null·&&·this.victimParts)
24 »       »       {32 »       »       {
25 »       »       »       PlayerControl·playerControl2·=·PlayerControl.AllPlayerControls.Find((PlayerControl·p)·=>·p.PlayerId·==·vInfo.PlayerId); 
26 »       »       »       GameData.PlayerOutfit·victimOutfit·=·playerControl2.CurrentOutfit; 
27 »       »       »       this.victimHat·=·victimOutfit.HatId;33 »       »       »       this.victimHat·=·initData.victimOutfit.HatId;
28 »       »       »       this.victimParts.SetBodyType(playerControl2.BodyType);34 »       »       »       this.victimParts.SetBodyType(initData.victimBodyType);
29 »       »       »       this.victimParts.UpdateFromPlayerData(vInfo,·playerControl2.CurrentOutfitType,·PlayerMaterial.MaskType.None,·false,·delegate35 »       »       »       this.victimParts.UpdateFromPlayerOutfit(initData.victimOutfit,·PlayerMaterial.MaskType.None,·false,·false,·delegate
30 »       »       »       {36 »       »       »       {
31 »       »       »       »       this.LoadVictimSkin(victimOutfit);37 »       »       »       »       this.LoadVictimSkin(initData.victimOutfit);
32 »       »       »       },·false);38 »       »       »       },·false);
 39 »       »       »       this.victimParts.SetHatLeftFacingVictim(this.leftFacingVictim);
33 »       »       »       this.victimParts.ToggleName(false);40 »       »       »       this.victimParts.ToggleName(false);
34 »       »       »       this.LoadVictimPet(victimOutfit);41 »       »       »       this.LoadVictimPet(initData.victimOutfit);
35 »       »       }42 »       »       }
36 »       }43 »       }
37 44
38 »       public·void·SetHatFloor()45 »       public·void·SetHatFloor()
39 »       {46 »       {
40 »       »       HatData·hatById·=·DestroyableSingleton<HatManager>.Instance.GetHatById(this.victimHat);47 »       »       HatData·hatById·=·DestroyableSingleton<HatManager>.Instance.GetHatById(this.victimHat);
41 »       »       if·(!hatById)48 »       »       if·(!hatById)
42 »       »       {49 »       »       {
43 »       »       »       return;50 »       »       »       return;
44 »       »       }51 »       »       }
45 »       »       this.victimParts.SetHatWithoutChangingColor(hatById);52 »       »       this.victimParts.SetHatWithoutChangingColor(hatById);
 53 »       »       this.victimParts.SetHatOnFloor();
 54 »       }
 55
 56 »       public·void·SetVisorFloor()
 57 »       {
46 »       »       this.victimParts.SetHatAndVisorOnFloor();58 »       »       this.victimParts.SetVisorOnFloor();
47 »       }59 »       }
48 60
49 »       public·void·PlayKillSound()61 »       public·void·PlayKillSound()
50 »       {62 »       {
51 »       »       if·(Constants.ShouldPlaySfx())63 »       »       if·(Constants.ShouldPlaySfx())
52 »       »       {64 »       »       {
53 »       »       »       SoundManager.Instance.PlaySound(this.Sfx,·false,·1f,·null).volume·=·0.8f;65 »       »       »       SoundManager.Instance.PlaySound(this.Sfx,·false,·1f,·null).volume·=·0.8f;
Offset 119, 82 lines modifiedOffset 131, 125 lines modified
119 »       »       »       »       }131 »       »       »       »       }
120 »       »       »       »       yield·return·null;132 »       »       »       »       yield·return·null;
121 »       »       »       }133 »       »       »       }
122 »       »       }134 »       »       }
123 »       »       yield·break;135 »       »       yield·break;
124 »       }136 »       }
125 137
126 »       private·void·LoadVictimSkin(GameData.PlayerOutfit·victimOutfit)138 »       private·void·LoadVictimSkin(NetworkedPlayerInfo.PlayerOutfit·outfit)
127 »       {139 »       {
128 »       »       SkinViewData·skin·=·ShipStatus.Instance.CosmeticsCache.GetSkin(victimOutfit.SkinId);140 »       »       SkinData·skinById·=·DestroyableSingleton<HatManager>.Instance.GetSkinById(outfit.SkinId);
 141 »       »       if·(!skinById·||·skinById.IsEmpty)
 142 »       »       {
 143 »       »       »       return;
 144 »       »       }
 145 »       »       SkinViewData·skinView·=·this.victimParts.GetSkinView();
129 »       »       SpriteAnim·skinSpriteAnim·=·this.victimParts.GetSkinSpriteAnim();146 »       »       SpriteAnim·skinSpriteAnim·=·this.victimParts.GetSkinSpriteAnim();
130 »       »       switch·(this.KillType)147 »       »       switch·(this.KillType)
131 »       »       {148 »       »       {
132 »       »       case·KillAnimType.Stab:149 »       »       case·KillAnimType.Stab:
133 »       »       »       skinSpriteAnim.Play(skin.KillStabVictim,·1f);150 »       »       »       skinSpriteAnim.Play(skinView.KillStabVictim,·1f);
134 »       »       »       return;151 »       »       »       return;
135 »       »       case·KillAnimType.Tongue:152 »       »       case·KillAnimType.Tongue:
136 »       »       »       skinSpriteAnim.Play(skin.KillTongueVictim,·1f);153 »       »       »       skinSpriteAnim.Play(skinView.KillTongueVictim,·1f);
137 »       »       »       return;154 »       »       »       return;
138 »       »       case·KillAnimType.Shoot:155 »       »       case·KillAnimType.Shoot:
139 »       »       »       skinSpriteAnim.Play(skin.KillShootVictim,·1f);156 »       »       »       skinSpriteAnim.Play(skinView.KillShootVictim,·1f);
140 »       »       »       return;157 »       »       »       return;
141 »       »       case·KillAnimType.Neck:158 »       »       case·KillAnimType.Neck:
142 »       »       »       skinSpriteAnim.Play(skin.KillNeckVictim,·1f);159 »       »       »       skinSpriteAnim.Play(skinView.KillNeckVictim,·1f);
143 »       »       »       return;160 »       »       »       return;
144 »       »       case·KillAnimType.RHM:161 »       »       case·KillAnimType.RHM:
145 »       »       »       skinSpriteAnim.Play(skin.KillRHMVictim,·1f);162 »       »       »       skinSpriteAnim.Play(skinView.KillRHMVictim,·1f);
 163 »       »       »       return;
 164 »       »       case·KillAnimType.Werewolf_Slash:
 165 »       »       »       skinSpriteAnim.Play(skinView.IdleLeftAnim,·1f);
146 »       »       »       return;166 »       »       »       return;
147 »       »       default:167 »       »       default:
148 »       »       »       return;168 »       »       »       return;
149 »       »       }169 »       »       }
150 »       }170 »       }
151 171
152 »       private·void·LoadKillerSkin(GameData.PlayerOutfit·killerOutfit)172 »       private·void·LoadKillerSkin(NetworkedPlayerInfo.PlayerOutfit·outfit)
153 »       {173 »       {
154 »       »       SkinViewData·skin·=·ShipStatus.Instance.CosmeticsCache.GetSkin(killerOutfit.SkinId);174 »       »       SkinData·skinById·=·DestroyableSingleton<HatManager>.Instance.GetSkinById(outfit.SkinId);
 175 »       »       if·(!skinById·||·skinById.IsEmpty)
 176 »       »       {
 177 »       »       »       return;
 178 »       »       }
 179 »       »       SkinViewData·skinView·=·this.killerParts.GetSkinView();
 180 »       »       SpriteAnim·skinSpriteAnim·=·this.killerParts.GetSkinSpriteAnim();
155 »       »       switch·(this.KillType)181 »       »       switch·(this.KillType)
156 »       »       {182 »       »       {
157 »       »       case·KillAnimType.Stab:183 »       »       case·KillAnimType.Stab:
158 »       »       »       this.killerParts.GetSkinSpriteAnim().Play(skin.KillStabImpostor,·1f);184 »       »       »       skinSpriteAnim.Play(skinView.KillStabImpostor,·1f);
159 »       »       »       return;185 »       »       »       return;
160 »       »       case·KillAnimType.Tongue:186 »       »       case·KillAnimType.Tongue:
161 »       »       »       this.killerParts.GetSkinSpriteAnim().Play(skin.KillTongueImpostor,·1f);187 »       »       »       skinSpriteAnim.Play(skinView.KillTongueImpostor,·1f);
Max diff block lines reached; 3062/8526 bytes (35.91%) of diff not shown.
3.32 KB
Assembly-CSharp/Palette.cs
    
Offset 46, 14 lines modifiedOffset 46, 36 lines modified
46 46
47 »       public·static·readonly·Color·Brown·=·new·Color(0.72f,·0.43f,·0.11f);47 »       public·static·readonly·Color·Brown·=·new·Color(0.72f,·0.43f,·0.11f);
48 48
49 »       public·static·readonly·Color·CrewmateBlue·=·new·Color32(140,·byte.MaxValue,·byte.MaxValue,·byte.MaxValue);49 »       public·static·readonly·Color·CrewmateBlue·=·new·Color32(140,·byte.MaxValue,·byte.MaxValue,·byte.MaxValue);
50 50
51 »       public·static·readonly·Color·ImpostorRed·=·new·Color32(byte.MaxValue,·25,·25,·byte.MaxValue);51 »       public·static·readonly·Color·ImpostorRed·=·new·Color32(byte.MaxValue,·25,·25,·byte.MaxValue);
52 52
 53 »       public·static·readonly·Color·CrewmateRoleBlue·=·new·Color32(17,·135,·178,·byte.MaxValue);
 54
 55 »       public·static·readonly·Color·CrewmateRoleHeaderBlue·=·new·Color32(120,·204,·236,·byte.MaxValue);
 56
 57 »       public·static·readonly·Color·CrewmateRoleHeaderTextBlue·=·new·Color32(14,·91,·119,·byte.MaxValue);
 58
 59 »       public·static·readonly·Color·CrewmateRoleHeaderDarkBlue·=·new·Color32(10,·87,·115,·byte.MaxValue);
 60
 61 »       public·static·readonly·Color·CrewmateRoleHeaderVeryDarkBlue·=·new·Color32(10,·87,·115,·127);
 62
 63 »       public·static·readonly·Color·CrewmateSettingChangeText·=·new·Color32(102,·171,·244,·byte.MaxValue);
 64
 65 »       public·static·readonly·Color·ImpostorRoleRed·=·new·Color32(211,·35,·35,·byte.MaxValue);
 66
 67 »       public·static·readonly·Color·ImpostorRoleHeaderRed·=·new·Color32(204,·83,·83,·byte.MaxValue);
 68
 69 »       public·static·readonly·Color·ImpostorRoleHeaderTextRed·=·new·Color32(88,·35,·35,·byte.MaxValue);
 70
 71 »       public·static·readonly·Color·ImpostorRoleHeaderDarkRed·=·new·Color32(137,·22,·22,·byte.MaxValue);
 72
 73 »       public·static·readonly·Color·ImpostorRoleHeaderVeryDarkRed·=·new·Color32(137,·22,·22,·127);
 74
53 »       public·static·readonly·Color·CosmicubeCellUnlockedColor·=·new·Color(0.023529412f,·0.78431374f,·0.39215687f);75 »       public·static·readonly·Color·CosmicubeCellUnlockedColor·=·new·Color(0.023529412f,·0.78431374f,·0.39215687f);
54 76
55 »       public·static·readonly·Color·CosmicubeCellLockedColor·=·new·Color(0.7019608f,·0.67058825f,·0.7176471f);77 »       public·static·readonly·Color·CosmicubeCellLockedColor·=·new·Color(0.7019608f,·0.67058825f,·0.7176471f);
56 78
57 »       public·static·readonly·Color·CosmicubeQuality_NamePlate·=·new·Color32(73,·174,·217,·byte.MaxValue);79 »       public·static·readonly·Color·CosmicubeQuality_NamePlate·=·new·Color32(73,·174,·217,·byte.MaxValue);
58 80
59 »       public·static·readonly·Color·CosmicubeQuality_Hat·=·new·Color32(225,·222,·0,·byte.MaxValue);81 »       public·static·readonly·Color·CosmicubeQuality_Hat·=·new·Color32(225,·222,·0,·byte.MaxValue);
Offset 140, 9 lines modifiedOffset 162, 53 lines modified
140 »       »       Palette.FromHex(14586547),162 »       »       Palette.FromHex(14586547),
141 »       »       Palette.FromHex(13810825),163 »       »       Palette.FromHex(13810825),
142 »       »       Palette.FromHex(4609636),164 »       »       Palette.FromHex(4609636),
143 »       »       Palette.FromHex(5325118),165 »       »       Palette.FromHex(5325118),
144 »       »       Palette.FromHex(11813730)166 »       »       Palette.FromHex(11813730)
145 »       };167 »       };
146 168
 169 »       public·static·readonly·Color32[]·TextColors·=·new·Color32[]
 170 »       {
 171 »       »       Palette.FromHex(12980497),
 172 »       »       Palette.FromHex(3166207),
 173 »       »       Palette.FromHex(1016620),
 174 »       »       Palette.FromHex(15619260),
 175 »       »       Palette.FromHex(16415747),
 176 »       »       Palette.FromHex(16576084),
 177 »       »       Palette.FromHex(0),
 178 »       »       Palette.FromHex(16777215),
 179 »       »       Palette.FromHex(8927470),
 180 »       »       Palette.FromHex(10052905),
 181 »       »       Palette.FromHex(3794140),
 182 »       »       Palette.FromHex(5304117),
 183 »       »       Palette.FromHex(12068436),
 184 »       »       Palette.FromHex(13729702),
 185 »       »       Palette.FromHex(16646078),
 186 »       »       Palette.FromHex(9280945),
 187 »       »       Palette.FromHex(9799796),
 188 »       »       Palette.FromHex(13723489)
 189 »       };
 190
 191 »       public·static·readonly·Color32[]·TextOutlineColors·=·new·Color32[]
 192 »       {
 193 »       »       Palette.FromHex(983040),
 194 »       »       Palette.FromHex(983040),
 195 »       »       Palette.FromHex(3335),
 196 »       »       Palette.FromHex(2555941),
 197 »       »       Palette.FromHex(983040),
 198 »       »       Palette.FromHex(3152384),
 199 »       »       Palette.FromHex(16777215),
 200 »       »       Palette.FromHex(0),
 201 »       »       Palette.FromHex(720911),
 202 »       »       Palette.FromHex(985088),
 203 »       »       Palette.FromHex(6682),
 204 »       »       Palette.FromHex(464640),
 205 »       »       Palette.FromHex(1703936),
 206 »       »       Palette.FromHex(5445419),
 207 »       »       Palette.FromHex(1248512),
 208 »       »       Palette.FromHex(0),
 209 »       »       Palette.FromHex(920064),
 210 »       »       Palette.FromHex(3604492)
 211 »       };
 212
147 »       public·static·readonly·Color32·VisorColor·=·new·Color32(149,·202,·220,·byte.MaxValue);213 »       public·static·readonly·Color32·VisorColor·=·new·Color32(149,·202,·220,·byte.MaxValue);
148 }214 }
4.7 KB
Assembly-CSharp/PassiveButton.cs
    
Offset 25, 18 lines modifiedOffset 25, 22 lines modified
25 »       {25 »       {
26 »       »       get26 »       »       get
27 »       »       {27 »       »       {
28 »       »       »       return·this.OnRepeat;28 »       »       »       return·this.OnRepeat;
29 »       »       }29 »       »       }
30 »       }30 »       }
31 31
 32 »       private·void·Awake()
 33 »       {
 34 »       »       this.SetPassiveButtonHoverStateInactive();
 35 »       }
 36
32 »       protected·override·void·Start()37 »       protected·override·void·Start()
33 »       {38 »       {
34 »       »       base.Start();39 »       »       base.Start();
35 »       »       this.SetPassiveButtonHoverStateInactive(); 
36 »       }40 »       }
37 41
38 »       protected·override·void·Update()42 »       protected·override·void·Update()
39 »       {43 »       {
40 »       »       base.Update();44 »       »       base.Update();
41 »       »       if·(this.HoldToUse·&&·this.beingHeldDown)45 »       »       if·(this.HoldToUse·&&·this.beingHeldDown)
42 »       »       {46 »       »       {
Offset 91, 14 lines modifiedOffset 95, 15 lines modified
91 »       »       {95 »       »       {
92 »       »       »       return;96 »       »       »       return;
93 »       »       }97 »       »       }
94 »       »       if·(this.ClickSound)98 »       »       if·(this.ClickSound)
95 »       »       {99 »       »       {
96 »       »       »       SoundManager.Instance.PlaySound(this.ClickSound,·false,·1f,·null);100 »       »       »       SoundManager.Instance.PlaySound(this.ClickSound,·false,·1f,·null);
97 »       »       }101 »       »       }
 102 »       »       this.repeatTimer·=·0f;
98 »       »       this.OnClick.Invoke();103 »       »       this.OnClick.Invoke();
99 »       }104 »       }
100 105
101 »       public·override·void·ReceiveRepeatDown()106 »       public·override·void·ReceiveRepeatDown()
102 »       {107 »       {
103 »       »       if·(!base.enabled)108 »       »       if·(!base.enabled)
104 »       »       {109 »       »       {
Offset 184, 14 lines modifiedOffset 189, 15 lines modified
184 »       »       »       });189 »       »       »       });
185 »       »       }190 »       »       }
186 »       }191 »       }
187 192
188 »       public·override·void·ReleaseButton()193 »       public·override·void·ReleaseButton()
189 »       {194 »       {
190 »       »       this.totalHeldTime·=·0f;195 »       »       this.totalHeldTime·=·0f;
 196 »       »       this.repeatTimer·=·0f;
191 »       }197 »       }
192 198
193 »       public·override·void·ReceiveMouseOut()199 »       public·override·void·ReceiveMouseOut()
194 »       {200 »       {
195 »       »       if·(!base.enabled)201 »       »       if·(!base.enabled)
196 »       »       {202 »       »       {
197 »       »       »       return;203 »       »       »       return;
Offset 216, 14 lines modifiedOffset 222, 26 lines modified
216 222
217 »       private·void·SetPassiveButtonHoverStateActive()223 »       private·void·SetPassiveButtonHoverStateActive()
218 »       {224 »       {
219 »       »       if·(!base.enabled)225 »       »       if·(!base.enabled)
220 »       »       {226 »       »       {
221 »       »       »       return;227 »       »       »       return;
222 »       »       }228 »       »       }
 229 »       »       if·(this.selectedInactiveSprites·!=·null)
 230 »       »       {
 231 »       »       »       this.selectedInactiveSprites.SetActive(false);
 232 »       »       »       if·(this.selectedSprites·!=·null·&&·this.selected)
 233 »       »       »       {
 234 »       »       »       »       this.selectedSprites.SetActive(true);
 235 »       »       »       }
 236 »       »       }
 237 »       »       if·(this.selected)
 238 »       »       {
 239 »       »       »       return;
 240 »       »       }
223 »       »       if·(this.activeSprites·!=·null)241 »       »       if·(this.activeSprites·!=·null)
224 »       »       {242 »       »       {
225 »       »       »       this.activeSprites.SetActive(true);243 »       »       »       this.activeSprites.SetActive(true);
226 »       »       }244 »       »       }
227 »       »       if·(this.inactiveSprites·!=·null)245 »       »       if·(this.inactiveSprites·!=·null)
228 »       »       {246 »       »       {
229 »       »       »       this.inactiveSprites.SetActive(false);247 »       »       »       this.inactiveSprites.SetActive(false);
Offset 240, 18 lines modifiedOffset 258, 39 lines modified
240 258
241 »       private·void·SetPassiveButtonHoverStateInactive()259 »       private·void·SetPassiveButtonHoverStateInactive()
242 »       {260 »       {
243 »       »       if·(!base.enabled)261 »       »       if·(!base.enabled)
244 »       »       {262 »       »       {
245 »       »       »       return;263 »       »       »       return;
246 »       »       }264 »       »       }
 265 »       »       if·(this.selectedInactiveSprites·!=·null·&&·this.selected)
 266 »       »       {
 267 »       »       »       if·(this.selectedSprites·!=·null)
 268 »       »       »       {
 269 »       »       »       »       this.selectedSprites.SetActive(false);
 270 »       »       »       }
 271 »       »       »       if·(this.inactiveSprites·!=·null)
 272 »       »       »       {
 273 »       »       »       »       this.inactiveSprites.SetActive(false);
 274 »       »       »       }
 275 »       »       »       this.selectedInactiveSprites.SetActive(true);
 276 »       »       »       return;
 277 »       »       }
 278 »       »       if·(this.selected)
 279 »       »       {
 280 »       »       »       return;
 281 »       »       }
247 »       »       if·(this.activeSprites·!=·null)282 »       »       if·(this.activeSprites·!=·null)
248 »       »       {283 »       »       {
249 »       »       »       this.activeSprites.SetActive(false);284 »       »       »       this.activeSprites.SetActive(false);
250 »       »       }285 »       »       }
 286 »       »       if·(this.selectedSprites·!=·null)
 287 »       »       {
 288 »       »       »       this.selectedSprites.SetActive(false);
 289 »       »       }
251 »       »       if·(this.inactiveSprites·!=·null)290 »       »       if·(this.inactiveSprites·!=·null)
252 »       »       {291 »       »       {
253 »       »       »       this.inactiveSprites.SetActive(true);292 »       »       »       this.inactiveSprites.SetActive(true);
254 »       »       }293 »       »       }
255 »       »       if·(this.disabledSprites·!=·null)294 »       »       if·(this.disabledSprites·!=·null)
256 »       »       {295 »       »       {
257 »       »       »       this.disabledSprites.SetActive(false);296 »       »       »       this.disabledSprites.SetActive(false);
Offset 272, 20 lines modifiedOffset 311, 70 lines modified
272 »       »       {311 »       »       {
273 »       »       »       this.inactiveSprites.SetActive(false);312 »       »       »       this.inactiveSprites.SetActive(false);
274 »       »       }313 »       »       }
275 »       »       if·(this.disabledSprites·!=·null)314 »       »       if·(this.disabledSprites·!=·null)
Max diff block lines reached; 2247/4752 bytes (47.29%) of diff not shown.
3.15 KB
Assembly-CSharp/PbExileController.cs
    
Offset 3, 43 lines modifiedOffset 3, 53 lines modified
3 using·PowerTools;3 using·PowerTools;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·PbExileController·:·ExileController6 public·class·PbExileController·:·ExileController
7 {7 {
8 »       protected·override·IEnumerator·Animate()8 »       protected·override·IEnumerator·Animate()
9 »       {9 »       {
 10 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 11 »       »       {
10 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);12 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);
 13 »       »       }
11 »       »       yield·return·Effects.Wait(0.75f);14 »       »       yield·return·Effects.Wait(0.75f);
12 »       »       yield·return·Effects.All(new·IEnumerator[]15 »       »       yield·return·Effects.All(new·IEnumerator[]
13 »       »       {16 »       »       {
14 »       »       »       this.PlayerFall(),17 »       »       »       this.PlayerFall(),
15 »       »       »       this.PlayerSpin(),18 »       »       »       this.PlayerSpin(),
16 »       »       »       this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f)19 »       »       »       this.HandleText(this.Duration·*·0.5f,·this.Duration·*·0.5f)
17 »       »       });20 »       »       });
18 »       »       if·(GameManager.Instance.LogicOptions.GetConfirmImpostor())21 »       »       if·(this.initData.confirmImpostor)
19 »       »       {22 »       »       {
20 »       »       »       this.ImpostorText.gameObject.SetActive(true);23 »       »       »       this.ImpostorText.gameObject.SetActive(true);
21 »       »       }24 »       »       }
22 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);25 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);
23 »       »       yield·return·new·WaitForSeconds(0.5f);26 »       »       yield·return·new·WaitForSeconds(0.5f);
 27 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 28 »       »       {
24 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);29 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);
 30 »       »       }
 31 »       »       else
 32 »       »       {
 33 »       »       »       yield·return·Effects.Wait(0.2f);
 34 »       »       }
25 »       »       if·(this.finalSinkCoroutine·!=·null)35 »       »       if·(this.finalSinkCoroutine·!=·null)
26 »       »       {36 »       »       {
27 »       »       »       base.StopCoroutine(this.finalSinkCoroutine);37 »       »       »       base.StopCoroutine(this.finalSinkCoroutine);
28 »       »       }38 »       »       }
29 »       »       base.WrapUp();39 »       »       base.WrapUp();
30 »       »       yield·break;40 »       »       yield·break;
31 »       }41 »       }
32 42
33 »       private·IEnumerator·PlayerFall()43 »       private·IEnumerator·PlayerFall()
34 »       {44 »       {
35 »       »       float·num·=·Camera.main.orthographicSize·+·1f;45 »       »       float·num·=·Camera.main.orthographicSize·+·1f;
36 »       »       Vector2·top·=·Vector2.up·*·num;46 »       »       Vector2·top·=·Vector2.up·*·num;
37 »       »       Vector2·bottom·=·Vector2.down·*·2.81f;47 »       »       Vector2·bottom·=·Vector2.down·*·2.81f;
38 »       »       bool·started·=·this.exiled·==·null;48 »       »       bool·started·=·this.initData·==·null·||·this.initData.outfit·==·null;
39 »       »       float·d·=·this.Duration·/·1.8f;49 »       »       float·d·=·this.Duration·/·1.8f;
40 »       »       for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime)50 »       »       for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime)
41 »       »       {51 »       »       {
42 »       »       »       float·num2·=·t·/·d;52 »       »       »       float·num2·=·t·/·d;
43 »       »       »       float·num3·=·this.LerpCurve.Evaluate(num2);53 »       »       »       float·num3·=·this.LerpCurve.Evaluate(num2);
44 »       »       »       Vector2·vector·=·Vector2.Lerp(top,·bottom,·num3);54 »       »       »       Vector2·vector·=·Vector2.Lerp(top,·bottom,·num3);
45 »       »       »       this.Player.transform.localPosition·=·vector;55 »       »       »       this.Player.transform.localPosition·=·vector;
Offset 64, 22 lines modifiedOffset 74, 22 lines modified
64 »       »       for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime)74 »       »       for·(float·t·=·0f;·t·<=·d;·t·+=·Time.deltaTime)
65 »       »       {75 »       »       {
66 »       »       »       float·num2·=·t·/·d;76 »       »       »       float·num2·=·t·/·d;
67 »       »       »       float·num3·=·(t·+·0.75f)·*·25f·/·Mathf.Exp(t·*·0.75f·+·1f);77 »       »       »       float·num3·=·(t·+·0.75f)·*·25f·/·Mathf.Exp(t·*·0.75f·+·1f);
68 »       »       »       this.Player.transform.Rotate(new·Vector3(0f,·0f,·num3·*·Time.deltaTime·*·5f));78 »       »       »       this.Player.transform.Rotate(new·Vector3(0f,·0f,·num3·*·Time.deltaTime·*·5f));
69 »       »       »       yield·return·null;79 »       »       »       yield·return·null;
70 »       »       }80 »       »       }
71 »       »       if·(!GameManager.Instance.LogicOptions.GetConfirmImpostor())81 »       »       if·(!this.initData.confirmImpostor)
72 »       »       {82 »       »       {
73 »       »       »       yield·break;83 »       »       »       yield·break;
74 »       »       }84 »       »       }
75 »       »       if·(this.exiled·!=·null)85 »       »       if·(this.initData·!=·null·&&·this.initData.outfit·!=·null)
76 »       »       {86 »       »       {
77 »       »       »       this.HandSlot.sprite·=·(this.exiled.Role.IsImpostor·?·this.GoodHand·:·this.BadHand);87 »       »       »       this.HandSlot.sprite·=·(this.initData.isImpostor·?·this.GoodHand·:·this.BadHand);
78 »       »       »       PlayerMaterial.SetColors(this.exiled.DefaultOutfit.ColorId,·this.HandSlot);88 »       »       »       PlayerMaterial.SetColors(this.initData.outfit.ColorId,·this.HandSlot);
79 »       »       }89 »       »       }
80 »       »       this.Player.transform.eulerAngles·=·new·Vector3(0f,·0f,·-10f);90 »       »       this.Player.transform.eulerAngles·=·new·Vector3(0f,·0f,·-10f);
81 »       »       float·num4·=·this.Duration·/·4f;91 »       »       float·num4·=·this.Duration·/·4f;
82 »       »       top.y·=·-1.78f;92 »       »       top.y·=·-1.78f;
83 »       »       yield·return·Effects.Overlerp(num4,·delegate(float·p)93 »       »       yield·return·Effects.Overlerp(num4,·delegate(float·p)
84 »       »       {94 »       »       {
85 »       »       »       this.Player.transform.localPosition·=·Vector2.LerpUnclamped(bottom,·top,·p);95 »       »       »       this.Player.transform.localPosition·=·Vector2.LerpUnclamped(bottom,·top,·p);
4.3 KB
Assembly-CSharp/PetBehaviour.cs
    
Offset 137, 14 lines modifiedOffset 137, 22 lines modified
137 »       {137 »       {
138 »       »       this.ForEachRenderer(true,·delegate(SpriteRenderer·x)138 »       »       this.ForEachRenderer(true,·delegate(SpriteRenderer·x)
139 »       »       {139 »       »       {
140 »       »       »       PlayerMaterial.SetMaskLayerBasedOnLocalPlayer(x,·true);140 »       »       »       PlayerMaterial.SetMaskLayerBasedOnLocalPlayer(x,·true);
141 »       »       });141 »       »       });
142 »       }142 »       }
143 143
 144 »       public·void·SetAlpha(float·alpha)
 145 »       {
 146 »       »       this.ForEachRenderer(true,·delegate(SpriteRenderer·x)
 147 »       »       {
 148 »       »       »       x.color·=·x.color.SetAlpha(alpha);
 149 »       »       });
 150 »       }
 151
144 »       public·bool·HasCrewmateColorShader()152 »       public·bool·HasCrewmateColorShader()
145 »       {153 »       {
146 »       »       SpriteRenderer[]·array·=·this.renderers;154 »       »       SpriteRenderer[]·array·=·this.renderers;
147 »       »       for·(int·i·=·0;·i·<·array.Length;·i++)155 »       »       for·(int·i·=·0;·i·<·array.Length;·i++)
148 »       »       {156 »       »       {
149 »       »       »       if·(array[i].sharedMaterial.shader.name.Contains("PlayerShader"))157 »       »       »       if·(array[i].sharedMaterial.shader.name.Contains("PlayerShader"))
150 »       »       »       {158 »       »       »       {
Offset 216, 24 lines modifiedOffset 224, 28 lines modified
216 »       »       {224 »       »       {
217 »       »       »       this.rigidbody.interpolation·=·RigidbodyInterpolation2D.Interpolate;225 »       »       »       this.rigidbody.interpolation·=·RigidbodyInterpolation2D.Interpolate;
218 »       »       }226 »       »       }
219 »       }227 »       }
220 228
221 »       private·void·Update()229 »       private·void·Update()
222 »       {230 »       {
 231 »       »       if·(this.viewOnly)
 232 »       »       {
 233 »       »       »       return;
 234 »       »       }
223 »       »       if·(this.manualMoving)235 »       »       if·(this.manualMoving)
224 »       »       {236 »       »       {
225 »       »       »       return;237 »       »       »       return;
226 »       »       }238 »       »       }
227 »       »       if·(!this.TargetPlayer·||·this.beingPet)239 »       »       if·(!this.TargetPlayer·||·this.beingPet)
228 »       »       {240 »       »       {
229 »       »       »       this.rigidbody.velocity·=·Vector2.zero;241 »       »       »       this.rigidbody.velocity·=·Vector2.zero;
230 »       »       »       return;242 »       »       »       return;
231 »       »       }243 »       »       }
232 »       »       if·(this.TargetPlayer.Data.IsDead)244 »       »       if·(this.TargetPlayer·!=·null·&&·this.TargetPlayer.Data·!=·null·&&·this.TargetPlayer.Data.IsDead)
233 »       »       {245 »       »       {
234 »       »       »       base.transform.position·=·this.TargetPlayer.GetTruePosition();246 »       »       »       base.transform.position·=·this.TargetPlayer.GetTruePosition();
235 »       »       »       this.SetMourning();247 »       »       »       this.SetMourning();
236 »       »       »       return;248 »       »       »       return;
237 »       »       }249 »       »       }
238 »       »       Vector2·truePosition·=·this.TargetPlayer.GetTruePosition();250 »       »       Vector2·truePosition·=·this.TargetPlayer.GetTruePosition();
239 »       »       Vector2·truePosition2·=·this.GetTruePosition();251 »       »       Vector2·truePosition2·=·this.GetTruePosition();
Offset 259, 15 lines modifiedOffset 271, 15 lines modified
259 »       »       »       vector·*=·0.7f;271 »       »       »       vector·*=·0.7f;
260 »       »       }272 »       »       }
261 »       »       AnimationClip·currentAnimation·=·this.animator.GetCurrentAnimation();273 »       »       AnimationClip·currentAnimation·=·this.animator.GetCurrentAnimation();
262 »       »       if·(vector.sqrMagnitude·>·0.01f)274 »       »       if·(vector.sqrMagnitude·>·0.01f)
263 »       »       {275 »       »       {
264 »       »       »       if·(currentAnimation·!=·this.walkClip)276 »       »       »       if·(currentAnimation·!=·this.walkClip)
265 »       »       »       {277 »       »       »       {
266 »       »       »       »       this.animator.Play(this.walkClip,·1f);278 »       »       »       »       this.StartWalkAnim();
267 »       »       »       }279 »       »       »       }
268 »       »       »       if·(vector.x·<·-0.01f)280 »       »       »       if·(vector.x·<·-0.01f)
269 »       »       »       {281 »       »       »       {
270 »       »       »       »       this.FlipX·=·true;282 »       »       »       »       this.FlipX·=·true;
271 »       »       »       }283 »       »       »       }
272 »       »       »       else·if·(vector.x·>·0.01f)284 »       »       »       else·if·(vector.x·>·0.01f)
273 »       »       »       {285 »       »       »       {
Offset 279, 14 lines modifiedOffset 291, 18 lines modified
279 »       »       »       this.animator.Play(this.idleClip,·1f);291 »       »       »       this.animator.Play(this.idleClip,·1f);
280 »       »       }292 »       »       }
281 »       »       this.rigidbody.velocity·=·vector;293 »       »       this.rigidbody.velocity·=·vector;
282 »       }294 »       }
283 295
284 »       private·void·LateUpdate()296 »       private·void·LateUpdate()
285 »       {297 »       {
 298 »       »       if·(this.viewOnly)
 299 »       »       {
 300 »       »       »       return;
 301 »       »       }
286 »       »       Vector3·localPosition·=·base.transform.localPosition;302 »       »       Vector3·localPosition·=·base.transform.localPosition;
287 »       »       localPosition.z·=·(localPosition.y·+·this.yOffset)·/·1000f·+·0.0002f;303 »       »       localPosition.z·=·(localPosition.y·+·this.yOffset)·/·1000f·+·0.0002f;
288 »       »       base.transform.localPosition·=·localPosition;304 »       »       base.transform.localPosition·=·localPosition;
289 »       }305 »       }
290 306
291 »       public·void·SetGettingPet(bool·petting,·Vector2·petPos)307 »       public·void·SetGettingPet(bool·petting,·Vector2·petPos)
292 »       {308 »       {
Offset 303, 14 lines modifiedOffset 319, 25 lines modified
303 »       }319 »       }
304 320
305 »       public·void·StartPetAnim()321 »       public·void·StartPetAnim()
306 »       {322 »       {
307 »       »       this.animator.Play(this.petClip,·1f);323 »       »       this.animator.Play(this.petClip,·1f);
308 »       }324 »       }
309 325
 326 »       public·void·StartWalkAnim()
 327 »       {
 328 »       »       this.animator.Play(this.walkClip,·1f);
 329 »       }
 330
 331 »       public·void·ToggleViewOnly(bool·value)
 332 »       {
 333 »       »       this.viewOnly·=·value;
 334 »       »       global::Logger.GlobalInstance.Info("[PetBehaviour]·Setting·Pet·'"·+·base.gameObject.name·+·"'·viewOnly·to·"·+·value.ToString().ToUpper(),·null);
 335 »       }
 336
310 »       private·Vector2·GetTruePosition()337 »       private·Vector2·GetTruePosition()
311 »       {338 »       {
312 »       »       return·base.transform.position·+·this.collider.offset·*·0.7f;339 »       »       return·base.transform.position·+·this.collider.offset·*·0.7f;
313 »       }340 »       }
314 341
315 »       private·void·ForEachRenderer(bool·includeShadows,·Action<SpriteRenderer>·action)342 »       private·void·ForEachRenderer(bool·includeShadows,·Action<SpriteRenderer>·action)
316 »       {343 »       {
Offset 343, 15 lines modifiedOffset 370, 15 lines modified
343 370
344 »       private·IEnumerator·WalkPetTo(Vector2·worldPos,·float·speed,·float·tolerance·=·0.01f)371 »       private·IEnumerator·WalkPetTo(Vector2·worldPos,·float·speed,·float·tolerance·=·0.01f)
345 »       {372 »       {
346 »       »       this.manualMoving·=·true;373 »       »       this.manualMoving·=·true;
347 »       »       Rigidbody2D·body·=·this.rigidbody;374 »       »       Rigidbody2D·body·=·this.rigidbody;
348 »       »       if·(this.animator.GetCurrentAnimation()·!=·this.walkClip)375 »       »       if·(this.animator.GetCurrentAnimation()·!=·this.walkClip)
349 »       »       {376 »       »       {
350 »       »       »       this.animator.Play(this.walkClip,·1f);377 »       »       »       this.StartWalkAnim();
351 »       »       }378 »       »       }
352 »       »       Vector2·del·=·worldPos·-·base.transform.position;379 »       »       Vector2·del·=·worldPos·-·base.transform.position;
353 »       »       while·(del.sqrMagnitude·>·tolerance)380 »       »       while·(del.sqrMagnitude·>·tolerance)
354 »       »       {381 »       »       {
355 »       »       »       Mathf.Clamp(del.magnitude·*·2f,·0.05f,·1f);382 »       »       »       Mathf.Clamp(del.magnitude·*·2f,·0.05f,·1f);
356 »       »       »       body.velocity·=·del.normalized·*·speed;383 »       »       »       body.velocity·=·del.normalized·*·speed;
Max diff block lines reached; 1013/4343 bytes (23.32%) of diff not shown.
965 B
Assembly-CSharp/PetData.cs
    
Offset 1, 11 lines modifiedOffset 1, 9 lines modified
1 using·System;1 using·System;
2 using·System.Collections; 
3 using·Innersloth.Assets;2 using·Innersloth.Assets;
4 using·UnityEngine; 
5 using·UnityEngine.AddressableAssets;3 using·UnityEngine.AddressableAssets;
6 4
7 public·class·PetData·:·CosmeticData,·IAddressableAssetProvider<PetBehaviour>5 public·class·PetData·:·CosmeticData,·IAddressableAssetProvider<PetBehaviour>
8 {6 {
9 »       public·bool·IsEmpty7 »       public·bool·IsEmpty
10 »       {8 »       {
11 »       »       get9 »       »       get
Offset 20, 22 lines modifiedOffset 18, 14 lines modified
20 »       }18 »       }
21 19
22 »       public·AssetReference·GetAssetReference()20 »       public·AssetReference·GetAssetReference()
23 »       {21 »       {
24 »       »       return·this.PetPrefabRef;22 »       »       return·this.PetPrefabRef;
25 »       }23 »       }
26 24
27 »       public·override·IEnumerator·CoLoadIcon(Action<Sprite,·AddressableAsset>·onLoaded) 
28 »       { 
29 »       »       AddressableAsset<PetBehaviour>·asset·=·this.CreateAddressableAsset(); 
30 »       »       yield·return·asset.CoLoadAsync(null); 
31 »       »       onLoaded(this.SpritePreview,·asset); 
32 »       »       yield·break; 
33 »       } 
34  
35 »       public·override·string·GetItemCategory()25 »       public·override·string·GetItemCategory()
36 »       {26 »       {
37 »       »       return·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PlayerPet,·Array.Empty<object>());27 »       »       return·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PlayerPet,·Array.Empty<object>());
38 »       }28 »       }
39 29
40 »       public·override·void·PreviewOnPlayer(PoolablePlayer·p,·int·colorId)30 »       public·override·void·PreviewOnPlayer(PoolablePlayer·p,·int·colorId)
41 »       {31 »       {
664 B
Assembly-CSharp/PingBehaviour.cs
    
Offset 20, 15 lines modifiedOffset 20, 15 lines modified
20 »       »       }20 »       »       }
21 »       »       Vector2·vector2·=·main.WorldToViewportPoint(this.target);21 »       »       Vector2·vector2·=·main.WorldToViewportPoint(this.target);
22 »       »       if·(this.AmSeeker·&&·base.Between(vector2.x,·0f,·1f)·&&·base.Between(vector2.y,·0f,·1f))22 »       »       if·(this.AmSeeker·&&·base.Between(vector2.x,·0f,·1f)·&&·base.Between(vector2.y,·0f,·1f))
23 »       »       {23 »       »       {
24 »       »       »       this.CloseBehaviour(vector,·num);24 »       »       »       this.CloseBehaviour(vector,·num);
25 »       »       »       return;25 »       »       »       return;
26 »       »       }26 »       »       }
27 »       »       base.DistancedBehaviour(vector2,·vector,·num,·main);27 »       »       this.DistancedBehaviour(vector2,·vector,·num,·main);
28 »       }28 »       }
29 29
30 »       protected·override·void·CloseBehaviour(Vector2·del,·float·delLen)30 »       protected·override·void·CloseBehaviour(Vector2·del,·float·delLen)
31 »       {31 »       {
32 »       »       base.transform.position·=·this.target;32 »       »       base.transform.position·=·this.target;
33 »       »       float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale);33 »       »       float·num·=·Mathf.Clamp(delLen,·0f,·this.MaxScale);
34 »       »       base.transform.localScale·=·new·Vector3(num,·num,·num);34 »       »       base.transform.localScale·=·new·Vector3(num,·num,·num);
860 B
Assembly-CSharp/PingTracker.cs
    
Offset 8, 13 lines modifiedOffset 8, 28 lines modified
8 »       {8 »       {
9 »       »       if·(AmongUsClient.Instance)9 »       »       if·(AmongUsClient.Instance)
10 »       »       {10 »       »       {
11 »       »       »       if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay)11 »       »       »       if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay)
12 »       »       »       {12 »       »       »       {
13 »       »       »       »       base.gameObject.SetActive(false);13 »       »       »       »       base.gameObject.SetActive(false);
14 »       »       »       }14 »       »       »       }
 15 »       »       »       if·(AmongUsClient.Instance.IsGameStarted)
 16 »       »       »       {
 17 »       »       »       »       this.aspectPosition.DistanceFromEdge·=·this.gamePos;
 18 »       »       »       }
 19 »       »       »       else
 20 »       »       »       {
 21 »       »       »       »       this.aspectPosition.DistanceFromEdge·=·this.lobbyPos;
 22 »       »       »       }
15 »       »       »       this.text.text·=·string.Format("Ping:·{0}·ms",·AmongUsClient.Instance.Ping);23 »       »       »       this.text.text·=·string.Format("PING:·<b>{0}·ms</b>",·AmongUsClient.Instance.Ping);
16 »       »       }24 »       »       }
17 »       }25 »       }
18 26
19 »       public·TextMeshPro·text;27 »       public·TextMeshPro·text;
 28
 29 »       [SerializeField]
 30 »       private·AspectPosition·aspectPosition;
 31
 32 »       private·Vector3·lobbyPos·=·new·Vector3(-0.21f,·0.65f,·0f);
 33
 34 »       private·Vector3·gamePos·=·new·Vector3(-0.21f,·0.32f,·0f);
20 }35 }
492 B
Assembly-CSharp/PlacePartsMinigame.cs
Ordering differences only
    
Offset 176, 16 lines modifiedOffset 176, 16 lines modified
176 »       private·Sprite·openHand;176 »       private·Sprite·openHand;
177 177
178 »       [SerializeField]178 »       [SerializeField]
179 »       private·Sprite·closeHand;179 »       private·Sprite·closeHand;
180 180
181 »       private·readonly·Controller·controller·=·new·Controller();181 »       private·readonly·Controller·controller·=·new·Controller();
182 182
183 »       [Header("Audio")] 
184 »       [SerializeField]183 »       [SerializeField]
 184 »       [Header("Audio")]
185 »       private·AudioClip[]·pickUpPartSfx;185 »       private·AudioClip[]·pickUpPartSfx;
186 186
187 »       [SerializeField]187 »       [SerializeField]
188 »       private·AudioClip[]·resetPartSfx;188 »       private·AudioClip[]·resetPartSfx;
189 189
190 »       [SerializeField]190 »       [SerializeField]
191 »       private·AudioClip[]·scrapOldPartSfx;191 »       private·AudioClip[]·scrapOldPartSfx;
1.04 KB
Assembly-CSharp/PlatformConsole.cs
    
Offset 23, 19 lines modifiedOffset 23, 19 lines modified
23 »       {23 »       {
24 »       »       get24 »       »       get
25 »       »       {25 »       »       {
26 »       »       »       return·ImageNames.UseButton;26 »       »       »       return·ImageNames.UseButton;
27 »       »       }27 »       »       }
28 »       }28 »       }
29 29
30 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)30 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
31 »       {31 »       {
32 »       »       float·num·=·float.MaxValue;32 »       »       float·num·=·float.MaxValue;
33 »       »       PlayerControl·@object·=·pc.Object;33 »       »       PlayerControl·@object·=·pc.Object;
34 »       »       couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!this.Platform.InUse·&&·Vector2.Distance(this.Platform.transform.position,·base.transform.position)·<·2f;34 »       »       couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!this.Platform.InUse·&&·Vector2.Distance(this.Platform.transform.position,·base.transform.position)·<·2f·&&·pc.Role.CanUse(this);
35 »       »       canUse·=·couldUse;35 »       »       canUse·=·couldUse;
36 »       »       if·(canUse)36 »       »       if·(canUse)
37 »       »       {37 »       »       {
38 »       »       »       Vector2·truePosition·=·@object.GetTruePosition();38 »       »       »       Vector2·truePosition·=·@object.GetTruePosition();
39 »       »       »       Vector3·position·=·base.transform.position;39 »       »       »       Vector3·position·=·base.transform.position;
40 »       »       »       num·=·Vector2.Distance(truePosition,·position);40 »       »       »       num·=·Vector2.Distance(truePosition,·position);
41 »       »       »       canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false);41 »       »       »       canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false);
485 B
Assembly-CSharp/PlayerAnimations.cs
Ordering differences only
    
Offset 247, 16 lines modifiedOffset 247, 16 lines modified
247 247
248 »       [SerializeField]248 »       [SerializeField]
249 »       private·SpriteRenderer·glowSpriteRenderer;249 »       private·SpriteRenderer·glowSpriteRenderer;
250 250
251 »       [SerializeField]251 »       [SerializeField]
252 »       private·List<PlayerAnimationGroup>·animationGroups;252 »       private·List<PlayerAnimationGroup>·animationGroups;
253 253
254 »       [Header("Med·Scan")] 
255 »       [SerializeField]254 »       [SerializeField]
 255 »       [Header("Med·Scan")]
256 »       private·SpriteAnim[]·scannerAnims;256 »       private·SpriteAnim[]·scannerAnims;
257 257
258 »       [SerializeField]258 »       [SerializeField]
259 »       private·SpriteRenderer[]·scannersImages;259 »       private·SpriteRenderer[]·scannersImages;
260 260
261 »       private·PlayerAnimationGroup·group;261 »       private·PlayerAnimationGroup·group;
262 262
775 B
Assembly-CSharp/PlayerBodyTypesExtensions.cs
    
Offset 109, 15 lines modifiedOffset 109, 15 lines modified
109 »       private·static·readonly·Dictionary<PlayerBodyTypes,·VisorOptions>·CustomVisorOptions·=·new·Dictionary<PlayerBodyTypes,·VisorOptions>109 »       private·static·readonly·Dictionary<PlayerBodyTypes,·VisorOptions>·CustomVisorOptions·=·new·Dictionary<PlayerBodyTypes,·VisorOptions>
110 »       {110 »       {
111 »       »       {111 »       »       {
112 »       »       »       PlayerBodyTypes.Normal,112 »       »       »       PlayerBodyTypes.Normal,
113 »       »       »       new·VisorOptions113 »       »       »       new·VisorOptions
114 »       »       »       {114 »       »       »       {
115 »       »       »       »       Enabled·=·true,115 »       »       »       »       Enabled·=·true,
116 »       »       »       »       HideDuringClimb·=·true116 »       »       »       »       HideDuringClimb·=·false
117 »       »       »       }117 »       »       »       }
118 »       »       },118 »       »       },
119 »       »       {119 »       »       {
120 »       »       »       PlayerBodyTypes.Long,120 »       »       »       PlayerBodyTypes.Long,
121 »       »       »       new·VisorOptions121 »       »       »       new·VisorOptions
122 »       »       »       {122 »       »       »       {
123 »       »       »       »       Enabled·=·true,123 »       »       »       »       Enabled·=·true,
Offset 125, 15 lines modifiedOffset 125, 15 lines modified
125 »       »       »       }125 »       »       »       }
126 »       »       },126 »       »       },
127 »       »       {127 »       »       {
128 »       »       »       PlayerBodyTypes.Horse,128 »       »       »       PlayerBodyTypes.Horse,
129 »       »       »       new·VisorOptions129 »       »       »       new·VisorOptions
130 »       »       »       {130 »       »       »       {
131 »       »       »       »       Enabled·=·true,131 »       »       »       »       Enabled·=·true,
132 »       »       »       »       HideDuringClimb·=·true132 »       »       »       »       HideDuringClimb·=·false
133 »       »       »       }133 »       »       »       }
134 »       »       },134 »       »       },
135 »       »       {135 »       »       {
136 »       »       »       PlayerBodyTypes.Seeker,136 »       »       »       PlayerBodyTypes.Seeker,
137 »       »       »       new·VisorOptions137 »       »       »       new·VisorOptions
138 »       »       »       {138 »       »       »       {
139 »       »       »       »       Enabled·=·false,139 »       »       »       »       Enabled·=·false,
59.0 KB
Assembly-CSharp/PlayerControl.cs
    
Offset 109, 22 lines modifiedOffset 109, 23 lines modified
109 »       »       »       this.CompleteTask(idx);109 »       »       »       this.CompleteTask(idx);
110 »       »       }110 »       »       }
111 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·1,·SendOption.Reliable);111 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·1,·SendOption.Reliable);
112 »       »       messageWriter.WritePacked(idx);112 »       »       messageWriter.WritePacked(idx);
113 »       »       messageWriter.EndMessage();113 »       »       messageWriter.EndMessage();
114 »       }114 »       }
115 115
116 »       public·void·RpcSetRole(RoleTypes·roleType)116 »       public·void·RpcSetRole(RoleTypes·roleType,·bool·canOverrideRole·=·false)
117 »       {117 »       {
118 »       »       if·(AmongUsClient.Instance.AmClient)118 »       »       if·(AmongUsClient.Instance.AmClient)
119 »       »       {119 »       »       {
120 »       »       »       this.SetRole(roleType);120 »       »       »       base.StartCoroutine(this.CoSetRole(roleType,·canOverrideRole));
121 »       »       }121 »       »       }
122 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·44,·SendOption.Reliable);122 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·44,·SendOption.Reliable);
123 »       »       messageWriter.Write((ushort)roleType);123 »       »       messageWriter.Write((ushort)roleType);
 124 »       »       messageWriter.Write(canOverrideRole);
124 »       »       messageWriter.EndMessage();125 »       »       messageWriter.EndMessage();
125 »       }126 »       }
126 127
127 »       public·void·CmdCheckName(string·name)128 »       public·void·CmdCheckName(string·name)
128 »       {129 »       {
129 »       »       if·(AmongUsClient.Instance.AmHost)130 »       »       if·(AmongUsClient.Instance.AmHost)
130 »       »       {131 »       »       {
Offset 147, 111 lines modifiedOffset 148, 117 lines modified
147 »       »       messageWriter.EndMessage();148 »       »       messageWriter.EndMessage();
148 »       }149 »       }
149 150
150 »       public·void·RpcSetVisor(string·visorId)151 »       public·void·RpcSetVisor(string·visorId)
151 »       {152 »       {
152 »       »       if·(AmongUsClient.Instance.AmClient)153 »       »       if·(AmongUsClient.Instance.AmClient)
153 »       »       {154 »       »       {
154 »       »       »       GameData.PlayerInfo·data·=·this.Data;155 »       »       »       NetworkedPlayerInfo·data·=·this.Data;
155 »       »       »       int?·num;156 »       »       »       int?·num;
156 »       »       »       if·(data·==·null)157 »       »       »       if·(data·==·null)
157 »       »       »       {158 »       »       »       {
158 »       »       »       »       num·=·null;159 »       »       »       »       num·=·null;
159 »       »       »       }160 »       »       »       }
160 »       »       »       else161 »       »       »       else
161 »       »       »       {162 »       »       »       {
162 »       »       »       »       GameData.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit;163 »       »       »       »       NetworkedPlayerInfo.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit;
163 »       »       »       »       num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null);164 »       »       »       »       num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null);
164 »       »       »       }165 »       »       »       }
165 »       »       »       int?·num2·=·num;166 »       »       »       int?·num2·=·num;
166 »       »       »       int·valueOrDefault·=·num2.GetValueOrDefault();167 »       »       »       int·valueOrDefault·=·num2.GetValueOrDefault();
167 »       »       »       this.SetVisor(visorId,·valueOrDefault);168 »       »       »       this.SetVisor(visorId,·valueOrDefault);
168 »       »       }169 »       »       }
169 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·42,·SendOption.Reliable);170 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·42,·SendOption.Reliable);
170 »       »       messageWriter.Write(visorId);171 »       »       messageWriter.Write(visorId);
 172 »       »       messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetVisorStr));
171 »       »       messageWriter.EndMessage();173 »       »       messageWriter.EndMessage();
172 »       }174 »       }
173 175
174 »       public·void·RpcSetNamePlate(string·namePlateId)176 »       public·void·RpcSetNamePlate(string·namePlateId)
175 »       {177 »       {
176 »       »       if·(AmongUsClient.Instance.AmClient)178 »       »       if·(AmongUsClient.Instance.AmClient)
177 »       »       {179 »       »       {
178 »       »       »       this.SetNamePlate(namePlateId);180 »       »       »       this.SetNamePlate(namePlateId);
179 »       »       }181 »       »       }
180 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·43,·SendOption.Reliable);182 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·43,·SendOption.Reliable);
181 »       »       messageWriter.Write(namePlateId);183 »       »       messageWriter.Write(namePlateId);
 184 »       »       messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetNamePlateStr));
182 »       »       messageWriter.EndMessage();185 »       »       messageWriter.EndMessage();
183 »       }186 »       }
184 187
185 »       public·void·RpcSetSkin(string·skinId)188 »       public·void·RpcSetSkin(string·skinId)
186 »       {189 »       {
187 »       »       if·(AmongUsClient.Instance.AmClient)190 »       »       if·(AmongUsClient.Instance.AmClient)
188 »       »       {191 »       »       {
189 »       »       »       GameData.PlayerInfo·data·=·this.Data;192 »       »       »       NetworkedPlayerInfo·data·=·this.Data;
190 »       »       »       int?·num;193 »       »       »       int?·num;
191 »       »       »       if·(data·==·null)194 »       »       »       if·(data·==·null)
192 »       »       »       {195 »       »       »       {
193 »       »       »       »       num·=·null;196 »       »       »       »       num·=·null;
194 »       »       »       }197 »       »       »       }
195 »       »       »       else198 »       »       »       else
196 »       »       »       {199 »       »       »       {
197 »       »       »       »       GameData.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit;200 »       »       »       »       NetworkedPlayerInfo.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit;
198 »       »       »       »       num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null);201 »       »       »       »       num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null);
199 »       »       »       }202 »       »       »       }
200 »       »       »       int?·num2·=·num;203 »       »       »       int?·num2·=·num;
201 »       »       »       int·valueOrDefault·=·num2.GetValueOrDefault();204 »       »       »       int·valueOrDefault·=·num2.GetValueOrDefault();
202 »       »       »       this.SetSkin(skinId,·valueOrDefault);205 »       »       »       this.SetSkin(skinId,·valueOrDefault);
203 »       »       }206 »       »       }
204 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·40,·SendOption.Reliable);207 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·40,·SendOption.Reliable);
205 »       »       messageWriter.Write(skinId);208 »       »       messageWriter.Write(skinId);
 209 »       »       messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetSkinStr));
206 »       »       messageWriter.EndMessage();210 »       »       messageWriter.EndMessage();
207 »       }211 »       }
208 212
209 »       public·void·RpcSetHat(string·hatId)213 »       public·void·RpcSetHat(string·hatId)
210 »       {214 »       {
211 »       »       if·(AmongUsClient.Instance.AmClient)215 »       »       if·(AmongUsClient.Instance.AmClient)
212 »       »       {216 »       »       {
213 »       »       »       GameData.PlayerInfo·data·=·this.Data;217 »       »       »       NetworkedPlayerInfo·data·=·this.Data;
214 »       »       »       int?·num;218 »       »       »       int?·num;
215 »       »       »       if·(data·==·null)219 »       »       »       if·(data·==·null)
216 »       »       »       {220 »       »       »       {
217 »       »       »       »       num·=·null;221 »       »       »       »       num·=·null;
218 »       »       »       }222 »       »       »       }
219 »       »       »       else223 »       »       »       else
220 »       »       »       {224 »       »       »       {
221 »       »       »       »       GameData.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit;225 »       »       »       »       NetworkedPlayerInfo.PlayerOutfit·defaultOutfit·=·data.DefaultOutfit;
222 »       »       »       »       num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null);226 »       »       »       »       num·=·((defaultOutfit·!=·null)·?·new·int?(defaultOutfit.ColorId)·:·null);
223 »       »       »       }227 »       »       »       }
224 »       »       »       int?·num2·=·num;228 »       »       »       int?·num2·=·num;
225 »       »       »       int·valueOrDefault·=·num2.GetValueOrDefault();229 »       »       »       int·valueOrDefault·=·num2.GetValueOrDefault();
226 »       »       »       this.SetHat(hatId,·valueOrDefault);230 »       »       »       this.SetHat(hatId,·valueOrDefault);
227 »       »       }231 »       »       }
228 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·39,·SendOption.Reliable);232 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·39,·SendOption.Reliable);
229 »       »       messageWriter.Write(hatId);233 »       »       messageWriter.Write(hatId);
 234 »       »       messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetHatStr));
230 »       »       messageWriter.EndMessage();235 »       »       messageWriter.EndMessage();
231 »       }236 »       }
232 237
233 »       public·void·RpcSetPet(string·petId)238 »       public·void·RpcSetPet(string·petId)
234 »       {239 »       {
235 »       »       if·(AmongUsClient.Instance.AmClient)240 »       »       if·(AmongUsClient.Instance.AmClient)
236 »       »       {241 »       »       {
237 »       »       »       this.SetPet(petId);242 »       »       »       this.SetPet(petId);
238 »       »       }243 »       »       }
239 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·41,·SendOption.Reliable);244 »       »       MessageWriter·messageWriter·=·AmongUsClient.Instance.StartRpc(this.NetId,·41,·SendOption.Reliable);
240 »       »       messageWriter.Write(petId);245 »       »       messageWriter.Write(petId);
 246 »       »       messageWriter.Write(this.GetNextRpcSequenceId(RpcCalls.SetPetStr));
241 »       »       messageWriter.EndMessage();247 »       »       messageWriter.EndMessage();
242 »       }248 »       }
243 249
244 »       public·void·RpcSetName(string·name)250 »       public·void·RpcSetName(string·name)
Max diff block lines reached; 56016/60329 bytes (92.85%) of diff not shown.
391 B
Assembly-CSharp/PlayerCustomizationMenu.cs
    
Offset 283, 14 lines modifiedOffset 283, 16 lines modified
283 283
284 »       public·GameObject·equippedText;284 »       public·GameObject·equippedText;
285 285
286 »       public·GameObject·nameplateMaskArea;286 »       public·GameObject·nameplateMaskArea;
287 287
288 »       public·GameObject·cubeArea;288 »       public·GameObject·cubeArea;
289 289
 290 »       public·GameObject·cosmicubeMenu;
 291
290 »       public·TextMeshPro·itemName;292 »       public·TextMeshPro·itemName;
291 293
292 »       public·Action·OnClose;294 »       public·Action·OnClose;
293 295
294 »       public·Action·OnOpen;296 »       public·Action·OnOpen;
295 297
296 »       public·GameObject·AprilFoolText;298 »       public·GameObject·AprilFoolText;
622 B
Assembly-CSharp/PlayerIdentifierButton.cs
    
Offset 1, 15 lines modifiedOffset 1, 15 lines modified
1 using·System;1 using·System;
2 using·InnerNet;2 using·InnerNet;
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·PlayerIdentifierButton·:·PoolableBehavior6 public·class·PlayerIdentifierButton·:·PoolableBehavior
7 {7 {
8 »       public·void·Populate(GameData.PlayerInfo·player)8 »       public·void·Populate(NetworkedPlayerInfo·player)
9 »       {9 »       {
10 »       »       this.NameText.text·=·player.PlayerName;10 »       »       this.NameText.text·=·player.PlayerName;
11 »       »       this.SetTargetPlayerId(player.PlayerId);11 »       »       this.SetTargetPlayerId(player.PlayerId);
12 »       »       this.PlayerPreview.UpdateFromEitherPlayerDataOrCache(player,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.SimpleUI,·false,·null);12 »       »       this.PlayerPreview.UpdateFromEitherPlayerDataOrCache(player,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.SimpleUI,·false,·null);
13 »       »       this.PlayerPreview.ToggleName(false);13 »       »       this.PlayerPreview.ToggleName(false);
14 »       }14 »       }
15 15
919 B
Assembly-CSharp/PlayerNameColor.cs
    
Offset 1, 25 lines modifiedOffset 1, 25 lines modified
1 using·System;1 using·System;
2 using·TMPro;2 using·TMPro;
3 using·UnityEngine;3 using·UnityEngine;
4 4
5 public·static·class·PlayerNameColor5 public·static·class·PlayerNameColor
6 {6 {
7 »       public·static·Color·Get(GameData.PlayerInfo·pc)7 »       public·static·Color·Get(NetworkedPlayerInfo·pc)
8 »       {8 »       {
9 »       »       return·PlayerNameColor.Get((pc·!=·null)·?·pc.Role·:·null);9 »       »       return·PlayerNameColor.Get((pc·!=·null)·?·pc.Role·:·null);
10 »       }10 »       }
11 11
12 »       public·static·void·Set(PlayerControl·pc)12 »       public·static·void·Set(PlayerControl·pc)
13 »       {13 »       {
14 »       »       GameData.PlayerInfo·data·=·pc.Data;14 »       »       NetworkedPlayerInfo·data·=·pc.Data;
15 »       »       PlayerNameColor.Set(pc,·(data·!=·null)·?·data.Role·:·null);15 »       »       PlayerNameColor.Set(pc,·(data·!=·null)·?·data.Role·:·null);
16 »       }16 »       }
17 17
18 »       public·static·void·Set(GameData.PlayerInfo·playerInfo,·TextMeshPro·name)18 »       public·static·void·Set(NetworkedPlayerInfo·playerInfo,·TextMeshPro·name)
19 »       {19 »       {
20 »       »       PlayerNameColor.Set(name,·(playerInfo·!=·null)·?·playerInfo.Role·:·null);20 »       »       PlayerNameColor.Set(name,·(playerInfo·!=·null)·?·playerInfo.Role·:·null);
21 »       }21 »       }
22 22
23 »       public·static·void·SetForRoleDirectly(PlayerControl·player,·RoleBehaviour·role)23 »       public·static·void·SetForRoleDirectly(PlayerControl·player,·RoleBehaviour·role)
24 »       {24 »       {
25 »       »       if·(!player.AmOwner)25 »       »       if·(!player.AmOwner)
5.77 KB
Assembly-CSharp/PlayerOption.cs
    
Offset 2, 76 lines modifiedOffset 2, 88 lines modified
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·AmongUs.GameOptions;3 using·AmongUs.GameOptions;
4 using·TMPro;4 using·TMPro;
5 using·UnityEngine;5 using·UnityEngine;
6 6
7 public·class·PlayerOption·:·OptionBehaviour7 public·class·PlayerOption·:·OptionBehaviour
8 {8 {
 9 »       public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer)
 10 »       {
 11 »       »       base.SetUpFromData(data,·maskLayer);
 12 »       »       PlayerSelectionGameSetting·playerSelectionGameSetting·=·data·as·PlayerSelectionGameSetting;
 13 »       »       if·(playerSelectionGameSetting·==·null)
 14 »       »       {
 15 »       »       »       return;
 16 »       »       }
 17 »       »       this.optionName·=·playerSelectionGameSetting.OptionName;
 18 »       }
 19
9 »       public·void·OnEnable()20 »       public·void·OnEnable()
10 »       {21 »       {
11 »       »       this.Values·=·new·List<GameData.PlayerInfo>(GameData.Instance.AllPlayers);22 »       »       this.Values·=·new·List<NetworkedPlayerInfo>(GameData.Instance.AllPlayers);
12 »       »       this.Values.Sort((GameData.PlayerInfo·a,·GameData.PlayerInfo·b)·=>·a.PlayerId.CompareTo(b.PlayerId));23 »       »       this.Values.Sort((NetworkedPlayerInfo·a,·NetworkedPlayerInfo·b)·=>·a.PlayerId.CompareTo(b.PlayerId));
13 »       »       this.Value·=·GameOptionsManager.Instance.GameHostOptions.GetInt(Int32OptionNames.ImpostorPlayerID);24 »       »       this.Value·=·GameOptionsManager.Instance.GameHostOptions.GetInt(Int32OptionNames.ImpostorPlayerID);
14 »       »       this.playerIndex·=·this.Values.FindIndex((GameData.PlayerInfo·p)·=>·(int)p.PlayerId·==·this.Value);25 »       »       this.playerIndex·=·this.Values.FindIndex((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.Value);
15 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>());26 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>());
16 »       »       this.OptionUnavailableTxt.color·=·Palette.DisabledGrey; 
17 »       »       this.SetValueText();27 »       »       this.SetValueText();
 28 »       »       this.AdjustButtonsActiveState();
18 »       } 
19  
20 »       private·void·Awake() 
21 »       { 
22 »       »       this.PlusBtn·=·this.PlusTxt.gameObject.GetComponent<PassiveButton>(); 
23 »       »       this.MinusBtn·=·this.MinusTxt.gameObject.GetComponent<PassiveButton>(); 
24 »       }29 »       }
25 30
26 »       private·void·SetValueText()31 »       private·void·SetValueText()
27 »       {32 »       {
28 »       »       bool·isGamePublic·=·AmongUsClient.Instance.IsGamePublic;33 »       »       bool·isGamePublic·=·AmongUsClient.Instance.IsGamePublic;
29 »       »       this.ValueText.gameObject.SetActive(!isGamePublic); 
30 »       »       if·(this.playerIndex·<·0)34 »       »       if·(this.playerIndex·<·0)
31 »       »       {35 »       »       {
32 »       »       »       this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>());36 »       »       »       this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.RoundRobin,·Array.Empty<object>());
33 »       »       }37 »       »       }
34 »       »       else38 »       »       else
35 »       »       {39 »       »       {
36 »       »       »       this.ValueText.text·=·this.Values[this.playerIndex].PlayerName;40 »       »       »       this.ValueText.text·=·this.Values[this.playerIndex].PlayerName;
37 »       »       }41 »       »       }
38 »       »       this.ValueText.color·=·(isGamePublic·?·Palette.DisabledGrey·:·Color.white); 
39 »       »       this.TitleText.color·=·(isGamePublic·?·Palette.DisabledGrey·:·Color.white);42 »       »       this.ValueText.gameObject.SetActive(!isGamePublic);
 43 »       »       this.ValueBox.gameObject.SetActive(!isGamePublic);
40 »       »       this.PlusTxt.gameObject.SetActive(!isGamePublic);44 »       »       this.PlusBtn.gameObject.SetActive(!isGamePublic);
41 »       »       this.MinusTxt.gameObject.SetActive(!isGamePublic);45 »       »       this.MinusBtn.gameObject.SetActive(!isGamePublic);
42 »       »       this.PlusBtn.enabled·=·!isGamePublic; 
43 »       »       this.MinusBtn.enabled·=·!isGamePublic; 
44 »       »       this.OptionUnavailableTxt.gameObject.SetActive(isGamePublic);46 »       »       this.OptionUnavailableTxt.gameObject.SetActive(isGamePublic);
45 »       }47 »       }
46 48
47 »       private·void·FixedUpdate()49 »       private·void·FixedUpdate()
48 »       {50 »       {
49 »       »       if·(GameData.Instance.AllPlayers.Count·!=·this.Values.Count)51 »       »       if·(GameData.Instance.AllPlayers.Count·!=·this.Values.Count)
50 »       »       {52 »       »       {
51 »       »       »       this.Values·=·new·List<GameData.PlayerInfo>(GameData.Instance.AllPlayers);53 »       »       »       this.Values·=·new·List<NetworkedPlayerInfo>(GameData.Instance.AllPlayers);
52 »       »       »       this.Values.Sort((GameData.PlayerInfo·a,·GameData.PlayerInfo·b)·=>·a.PlayerId.CompareTo(b.PlayerId));54 »       »       »       this.Values.Sort((NetworkedPlayerInfo·a,·NetworkedPlayerInfo·b)·=>·a.PlayerId.CompareTo(b.PlayerId));
53 »       »       »       this.playerIndex·=·this.Values.FindIndex((GameData.PlayerInfo·p)·=>·(int)p.PlayerId·==·this.Value);55 »       »       »       this.playerIndex·=·this.Values.FindIndex((NetworkedPlayerInfo·p)·=>·(int)p.PlayerId·==·this.Value);
54 »       »       »       this.SetValueText();56 »       »       »       this.SetValueText();
55 »       »       }57 »       »       }
56 »       »       this.CheckValueChanged();58 »       »       this.CheckValueChanged();
57 »       }59 »       }
58 60
59 »       public·void·Increase()61 »       public·void·Increase()
60 »       {62 »       {
 63 »       »       if·(this.playerIndex·>=·this.Values.Count·-·1)
 64 »       »       {
 65 »       »       »       return;
 66 »       »       }
61 »       »       this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·+·1,·-1,·this.Values.Count·-·1));67 »       »       this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·+·1,·-1,·this.Values.Count·-·1));
62 »       »       this.CheckValueChanged();68 »       »       this.CheckValueChanged();
63 »       »       this.OnValueChanged(this);69 »       »       this.OnValueChanged(this);
 70 »       »       this.AdjustButtonsActiveState();
64 »       }71 »       }
65 72
66 »       public·void·Decrease()73 »       public·void·Decrease()
67 »       {74 »       {
 75 »       »       if·(this.playerIndex·<·0)
 76 »       »       {
 77 »       »       »       return;
 78 »       »       }
68 »       »       this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·-·1,·-1,·this.Values.Count·-·1));79 »       »       this.UpdatePlayerIndex(Mathf.Clamp(this.playerIndex·-·1,·-1,·this.Values.Count·-·1));
69 »       »       this.CheckValueChanged();80 »       »       this.CheckValueChanged();
70 »       »       this.OnValueChanged(this);81 »       »       this.OnValueChanged(this);
 82 »       »       this.AdjustButtonsActiveState();
71 »       }83 »       }
72 84
73 »       public·override·int·GetInt()85 »       public·override·int·GetInt()
74 »       {86 »       {
75 »       »       if·(AmongUsClient.Instance.IsGamePublic)87 »       »       if·(AmongUsClient.Instance.IsGamePublic)
76 »       »       {88 »       »       {
77 »       »       »       return·-1;89 »       »       »       return·-1;
Offset 93, 15 lines modifiedOffset 105, 44 lines modified
93 105
94 »       private·void·CheckValueChanged()106 »       private·void·CheckValueChanged()
95 »       {107 »       {
96 »       »       if·(this.oldValue·!=·this.Value)108 »       »       if·(this.oldValue·!=·this.Value)
97 »       »       {109 »       »       {
98 »       »       »       this.oldValue·=·this.Value;110 »       »       »       this.oldValue·=·this.Value;
99 »       »       »       this.SetValueText();111 »       »       »       this.SetValueText();
 112 »       »       »       this.UpdateValue();
 113 »       »       }
 114 »       }
 115
 116 »       private·void·UpdateValue()
 117 »       {
 118 »       »       if·(this.optionName·!=·Int32OptionNames.Invalid)
 119 »       »       {
 120 »       »       »       GameOptionsManager.Instance.CurrentGameOptions.SetInt(this.optionName,·this.GetInt());
 121 »       »       »       return;
 122 »       »       }
 123 »       »       Debug.LogError("Could·not·update·value·of·"·+·this.Title.ToString());
 124 »       }
 125
 126 »       private·void·AdjustButtonsActiveState()
 127 »       {
 128 »       »       if·(this.Value·<·0)
 129 »       »       {
 130 »       »       »       this.MinusBtn.SetInteractable(false);
 131 »       »       »       this.PlusBtn.SetInteractable(true);
Max diff block lines reached; 967/5843 bytes (16.55%) of diff not shown.
624 B
Assembly-CSharp/PlayerPettingHand.cs
    
Offset 31, 16 lines modifiedOffset 31, 24 lines modified
31 »       }31 »       }
32 32
33 »       public·void·StopPetting()33 »       public·void·StopPetting()
34 »       {34 »       {
35 »       »       base.gameObject.SetActive(false);35 »       »       base.gameObject.SetActive(false);
36 »       }36 »       }
37 37
 38 »       public·void·SetAlpha(float·alphaValue)
 39 »       {
 40 »       »       this.HandSprite.color·=·this.HandSprite.color.SetAlpha(alphaValue);
 41 »       »       this.hearts.color·=·this.hearts.color.SetAlpha(alphaValue);
 42 »       }
 43
38 »       public·SpriteRenderer·HandSprite;44 »       public·SpriteRenderer·HandSprite;
39 45
 46 »       public·SpriteRenderer·hearts;
 47
40 »       public·SpriteAnim·HandSpriteAnim;48 »       public·SpriteAnim·HandSpriteAnim;
41 49
42 »       public·AnimationClip·PetClip;50 »       public·AnimationClip·PetClip;
43 51
44 »       private·const·int·PET_ANIMATION_START_FRAME·=·6;52 »       private·const·int·PET_ANIMATION_START_FRAME·=·6;
45 53
46 »       private·const·float·ZPOS_PETTING·=·1E-05f;54 »       private·const·float·ZPOS_PETTING·=·1E-05f;
4.43 KB
Assembly-CSharp/PlayerPhysics.cs
    
Offset 198, 25 lines modifiedOffset 198, 29 lines modified
198 »       »       this.myPlayer.cosmetics.EnsureInitialized(bodyType);198 »       »       this.myPlayer.cosmetics.EnsureInitialized(bodyType);
199 »       »       this.Animations.SetBodyType(bodyType,·this.myPlayer.cosmetics.FlippedCosmeticOffset,·this.myPlayer.cosmetics.NormalCosmeticOffset);199 »       »       this.Animations.SetBodyType(bodyType,·this.myPlayer.cosmetics.FlippedCosmeticOffset,·this.myPlayer.cosmetics.NormalCosmeticOffset);
200 »       »       this.Animations.PlayIdleAnimation();200 »       »       this.Animations.PlayIdleAnimation();
201 »       }201 »       }
202 202
203 »       private·void·FixedUpdate()203 »       private·void·FixedUpdate()
204 »       {204 »       {
205 »       »       GameData.PlayerInfo·data·=·this.myPlayer.Data;205 »       »       NetworkedPlayerInfo·data·=·this.myPlayer.Data;
206 »       »       bool·flag·=·data·!=·null·&&·data.IsDead;206 »       »       bool·flag·=·data·!=·null·&&·data.IsDead;
207 »       »       this.HandleAnimation(flag);207 »       »       this.HandleAnimation(flag);
208 »       »       if·(base.AmOwner)208 »       »       if·(base.AmOwner)
209 »       »       {209 »       »       {
210 »       »       »       if·(this.myPlayer.CanMove·&&·GameData.Instance·&&·DestroyableSingleton<HudManager>.InstanceExists·&&·DestroyableSingleton<HudManager>.Instance.joystick·!=·null)210 »       »       »       if·(this.myPlayer.CanMove·&&·GameData.Instance·&&·DestroyableSingleton<HudManager>.InstanceExists·&&·DestroyableSingleton<HudManager>.Instance.joystick·!=·null)
211 »       »       »       {211 »       »       »       {
212 »       »       »       »       this.SetNormalizedVelocity(DestroyableSingleton<HudManager>.Instance.joystick.DeltaL);212 »       »       »       »       this.SetNormalizedVelocity(DestroyableSingleton<HudManager>.Instance.joystick.DeltaL);
213 »       »       »       }213 »       »       »       }
214 »       »       »       this.CheckCancelPetting();214 »       »       »       this.CheckCancelPetting();
215 »       »       }215 »       »       }
 216 »       »       if·(this.myPlayer.PhantomFadeActive)
 217 »       »       {
 218 »       »       »       this.myPlayer.cosmetics.SetPhantomRoleAlpha(this.myPlayer.CalculatedAlpha);
 219 »       »       }
216 »       }220 »       }
217 221
218 »       public·Vector2·GetVelocity()222 »       public·Vector2·GetVelocity()
219 »       {223 »       {
220 »       »       return·this.body.velocity;224 »       »       return·this.body.velocity;
221 »       }225 »       }
222 226
Offset 260, 21 lines modifiedOffset 264, 21 lines modified
260 »       »       »       »       }264 »       »       »       »       }
261 »       »       »       }265 »       »       »       }
262 »       »       });266 »       »       });
263 »       }267 »       }
264 268
265 »       public·void·StartClimb(bool·down)269 »       public·void·StartClimb(bool·down)
266 »       {270 »       {
 271 »       »       this.FlipX·=·false;
267 »       »       this.Animations.PlayClimbAnimation(down);272 »       »       this.Animations.PlayClimbAnimation(down);
268 »       »       this.myPlayer.cosmetics.AnimateClimb(down);273 »       »       this.myPlayer.cosmetics.AnimateClimb(down);
269 »       »       this.myPlayer.cosmetics.TogglePetVisible(false);274 »       »       this.myPlayer.cosmetics.TogglePetVisible(false);
270 »       »       if·(this.bodyType.GetVisorOptions().HideDuringClimb)275 »       »       if·(this.bodyType.GetVisorOptions().HideDuringClimb)
271 »       »       {276 »       »       {
272 »       »       »       this.myPlayer.cosmetics.ToggleVisor(false);277 »       »       »       this.myPlayer.cosmetics.ToggleVisor(false);
273 »       »       »       this.FlipX·=·false; 
274 »       »       }278 »       »       }
275 »       }279 »       }
276 280
277 »       private·void·ClimbLadder(Ladder·source,·byte·climbLadderSid)281 »       private·void·ClimbLadder(Ladder·source,·byte·climbLadderSid)
278 »       {282 »       {
279 »       »       if·(!NetHelpers.SidGreaterThan(climbLadderSid,·this.lastClimbLadderSid))283 »       »       if·(!NetHelpers.SidGreaterThan(climbLadderSid,·this.lastClimbLadderSid))
280 »       »       {284 »       »       {
Offset 300, 16 lines modifiedOffset 304, 16 lines modified
300 »       »       this.myPlayer.NetTransform.enabled·=·false;304 »       »       this.myPlayer.NetTransform.enabled·=·false;
301 »       »       this.myPlayer.SetKinematic(true);305 »       »       this.myPlayer.SetKinematic(true);
302 »       »       this.myPlayer.NetTransform.ClearPositionQueues();306 »       »       this.myPlayer.NetTransform.ClearPositionQueues();
303 »       »       if·(this.myPlayer.AmOwner)307 »       »       if·(this.myPlayer.AmOwner)
304 »       »       {308 »       »       {
305 »       »       »       this.myPlayer.MyPhysics.inputHandler.enabled·=·true;309 »       »       »       this.myPlayer.MyPhysics.inputHandler.enabled·=·true;
306 »       »       }310 »       »       }
307 »       »       GameServerUtils.DebugEstimatedWalkTo("walkToSeconds·(estimated)",·base.transform.position,·this.myPlayer.Collider.offset,·source.transform.position,·this.Speed,·0.001f);311 »       »       GameServerUtils.DebugEstimatedWalkTo("walkToSeconds·(estimated)",·base.transform.position,·this.myPlayer.Collider.offset,·source.transform.position,·this.Speed,·0.0005f);
308 »       »       yield·return·this.WalkPlayerTo(source.transform.position,·0.001f,·1f,·false);312 »       »       yield·return·this.WalkPlayerTo(source.transform.position,·0.0005f,·1f,·false);
309 »       »       GameServerUtils.DebugTime("walkToSeconds",·ref·ladderTime,·Time.time);313 »       »       GameServerUtils.DebugTime("walkToSeconds",·ref·ladderTime,·Time.time);
310 »       »       yield·return·Effects.Wait(0.1f);314 »       »       yield·return·Effects.Wait(0.1f);
311 »       »       GameServerUtils.DebugTime("waitSeconds",·ref·ladderTime,·Time.time);315 »       »       GameServerUtils.DebugTime("waitSeconds",·ref·ladderTime,·Time.time);
312 »       »       this.StartClimb(source.IsTop);316 »       »       this.StartClimb(source.IsTop);
313 »       »       if·(Constants.ShouldPlaySfx()·&&·PlayerControl.LocalPlayer·==·this.myPlayer)317 »       »       if·(Constants.ShouldPlaySfx()·&&·PlayerControl.LocalPlayer·==·this.myPlayer)
314 »       »       {318 »       »       {
315 »       »       »       this.myPlayer.FootSteps.clip·=·source.UseSound;319 »       »       »       this.myPlayer.FootSteps.clip·=·source.UseSound;
Offset 354, 15 lines modifiedOffset 358, 15 lines modified
354 »       »       base.enabled·=·true;358 »       »       base.enabled·=·true;
355 »       »       if·(this.myPlayer)359 »       »       if·(this.myPlayer)
356 »       »       {360 »       »       {
357 »       »       »       this.myPlayer.petting·=·false;361 »       »       »       this.myPlayer.petting·=·false;
358 »       »       »       this.myPlayer.inVent·=·false;362 »       »       »       this.myPlayer.inVent·=·false;
359 »       »       »       this.myPlayer.isKilling·=·false;363 »       »       »       this.myPlayer.isKilling·=·false;
360 »       »       »       this.myPlayer.walkingToVent·=·false;364 »       »       »       this.myPlayer.walkingToVent·=·false;
361 »       »       »       this.myPlayer.Visible·=·true;365 »       »       »       this.myPlayer.onLadder·=·false;
362 »       »       »       this.myPlayer.shapeshifting·=·false;366 »       »       »       this.myPlayer.shapeshifting·=·false;
363 »       »       »       this.myPlayer.waitingForShapeshiftResponse·=·false;367 »       »       »       this.myPlayer.waitingForShapeshiftResponse·=·false;
364 »       »       »       this.myPlayer.cosmetics.SetScale(this.Animations.DefaultPlayerScale,·this.myPlayer.defaultCosmeticsScale);368 »       »       »       this.myPlayer.cosmetics.SetScale(this.Animations.DefaultPlayerScale,·this.myPlayer.defaultCosmeticsScale);
365 »       »       »       this.myPlayer.cosmetics.PettingHand.StopPetting();369 »       »       »       this.myPlayer.cosmetics.PettingHand.StopPetting();
366 »       »       »       this.myPlayer.NetTransform.enabled·=·true;370 »       »       »       this.myPlayer.NetTransform.enabled·=·true;
367 »       »       »       this.myPlayer.NetTransform.SetPaused(false);371 »       »       »       this.myPlayer.NetTransform.SetPaused(false);
368 »       »       »       this.myPlayer.SetKinematic(false);372 »       »       »       this.myPlayer.SetKinematic(false);
Offset 380, 15 lines modifiedOffset 384, 15 lines modified
380 »       }384 »       }
381 385
382 »       public·void·ResetAnimState()386 »       public·void·ResetAnimState()
383 »       {387 »       {
384 »       »       this.myPlayer.FootSteps.Stop();388 »       »       this.myPlayer.FootSteps.Stop();
385 »       »       this.myPlayer.FootSteps.loop·=·false;389 »       »       this.myPlayer.FootSteps.loop·=·false;
386 »       »       this.myPlayer.cosmetics.SetHatAndVisorIdle(this.myPlayer.CurrentOutfit.ColorId);390 »       »       this.myPlayer.cosmetics.SetHatAndVisorIdle(this.myPlayer.CurrentOutfit.ColorId);
387 »       »       GameData.PlayerInfo·data·=·this.myPlayer.Data;391 »       »       NetworkedPlayerInfo·data·=·this.myPlayer.Data;
388 »       »       if·(data·==·null·||·!data.IsDead)392 »       »       if·(data·==·null·||·!data.IsDead)
389 »       »       {393 »       »       {
390 »       »       »       this.myPlayer.cosmetics.AnimateSkinIdle();394 »       »       »       this.myPlayer.cosmetics.AnimateSkinIdle();
391 »       »       »       this.Animations.PlayIdleAnimation();395 »       »       »       this.Animations.PlayIdleAnimation();
392 »       »       »       this.myPlayer.Visible·=·true;396 »       »       »       this.myPlayer.Visible·=·true;
393 »       »       »       this.myPlayer.SetHatAndVisorAlpha(1f);397 »       »       »       this.myPlayer.SetHatAndVisorAlpha(1f);
394 »       »       »       return;398 »       »       »       return;
Offset 765, 14 lines modifiedOffset 769, 16 lines modified
765 »       [NonSerialized]769 »       [NonSerialized]
766 »       public·SpecialInputHandler·inputHandler;770 »       public·SpecialInputHandler·inputHandler;
767 771
768 »       public·float·Speed·=·4.5f;772 »       public·float·Speed·=·4.5f;
769 773
770 »       public·float·GhostSpeed·=·3f;774 »       public·float·GhostSpeed·=·3f;
771 775
 776 »       private·const·float·ClimbPositionTolerance·=·0.0005f;
 777
772 »       private·readonly·global::Logger·logger·=·new·global::Logger("PlayerPhysics",·global::Logger.Level.Debug,·global::Logger.Category.Gameplay);778 »       private·readonly·global::Logger·logger·=·new·global::Logger("PlayerPhysics",·global::Logger.Level.Debug,·global::Logger.Category.Gameplay);
773 779
774 »       private·Rigidbody2D·body;780 »       private·Rigidbody2D·body;
775 781
776 »       private·PlayerControl·myPlayer;782 »       private·PlayerControl·myPlayer;
777 783
778 »       private·PlayerBodyTypes·bodyType;784 »       private·PlayerBodyTypes·bodyType;
1.08 KB
Assembly-CSharp/PlayerPurchasesData.cs
    
Offset 5, 15 lines modifiedOffset 5, 15 lines modified
5 using·AmongUs.Data.Player;5 using·AmongUs.Data.Player;
6 using·UnityEngine;6 using·UnityEngine;
7 7
8 public·class·PlayerPurchasesData8 public·class·PlayerPurchasesData
9 {9 {
10 »       public·PlayerPurchasesData()10 »       public·PlayerPurchasesData()
11 »       {11 »       {
12 »       »       this.purchases·=·new·HashSet<string>(StringComparer.OrdinalIgnoreCase);12 »       »       this.purchases·=·new·List<string>();
13 »       }13 »       }
14 14
15 »       public·void·UpdateLegacyPurchases()15 »       public·void·UpdateLegacyPurchases()
16 »       {16 »       {
17 »       »       foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS)17 »       »       foreach·(string·text·in·PlayerStoreData.LEGACY_PURCHASE_KEYS)
18 »       »       {18 »       »       {
19 »       »       »       this.ClearPurchase(text);19 »       »       »       this.ClearPurchase(text);
Offset 60, 20 lines modifiedOffset 60, 20 lines modified
60 »       public·void·ClearPurchase(string·key)60 »       public·void·ClearPurchase(string·key)
61 »       {61 »       {
62 »       »       this.purchases.Remove(key);62 »       »       this.purchases.Remove(key);
63 »       }63 »       }
64 64
65 »       public·void·ClearAllPurchases()65 »       public·void·ClearAllPurchases()
66 »       {66 »       {
67 »       »       HashSet<string>·hashSet·=·new·HashSet<string>(StringComparer.OrdinalIgnoreCase);67 »       »       List<string>·list·=·new·List<string>();
68 »       »       foreach·(string·text·in·this.purchases)68 »       »       foreach·(string·text·in·this.purchases)
69 »       »       {69 »       »       {
70 »       »       »       if·(Enumerable.Contains<string>(PlayerStoreData.LEGACY_PURCHASE_KEYS,·text))70 »       »       »       if·(Enumerable.Contains<string>(PlayerStoreData.LEGACY_PURCHASE_KEYS,·text))
71 »       »       »       {71 »       »       »       {
72 »       »       »       »       hashSet.Add(text);72 »       »       »       »       list.Add(text);
73 »       »       »       }73 »       »       »       }
74 »       »       }74 »       »       }
75 »       »       this.purchases·=·hashSet;75 »       »       this.purchases·=·list;
76 »       }76 »       }
77 77
78 »       private·HashSet<string>·purchases;78 »       private·List<string>·purchases;
79 }79 }
761 B
Assembly-CSharp/PlayerTab.cs
    
Offset 102, 19 lines modifiedOffset 102, 19 lines modified
102 »       {102 »       {
103 »       »       for·(int·i·=·0;·i·<·Palette.PlayerColors.Length;·i++)103 »       »       for·(int·i·=·0;·i·<·Palette.PlayerColors.Length;·i++)
104 »       »       {104 »       »       {
105 »       »       »       this.AvailableColors.Add(i);105 »       »       »       this.AvailableColors.Add(i);
106 »       »       }106 »       »       }
107 »       »       if·(GameData.Instance)107 »       »       if·(GameData.Instance)
108 »       »       {108 »       »       {
109 »       »       »       List<GameData.PlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers;109 »       »       »       List<NetworkedPlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers;
110 »       »       »       for·(int·j·=·0;·j·<·allPlayers.Count;·j++)110 »       »       »       for·(int·j·=·0;·j·<·allPlayers.Count;·j++)
111 »       »       »       {111 »       »       »       {
112 »       »       »       »       GameData.PlayerInfo·playerInfo·=·allPlayers[j];112 »       »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·allPlayers[j];
113 »       »       »       »       this.AvailableColors.Remove(playerInfo.DefaultOutfit.ColorId);113 »       »       »       »       this.AvailableColors.Remove(networkedPlayerInfo.DefaultOutfit.ColorId);
114 »       »       »       }114 »       »       »       }
115 »       »       }115 »       »       }
116 »       }116 »       }
117 117
118 »       private·int·GetCurrentColorId()118 »       private·int·GetCurrentColorId()
119 »       {119 »       {
120 »       »       int·num;120 »       »       int·num;
998 B
Assembly-CSharp/PlayerVoteArea.cs
    
Offset 233, 15 lines modifiedOffset 233, 15 lines modified
233 »       »       this.VotedFor·=·reader.ReadByte();233 »       »       this.VotedFor·=·reader.ReadByte();
234 »       »       this.DidReport·=·reader.ReadBoolean();234 »       »       this.DidReport·=·reader.ReadBoolean();
235 »       »       this.Flag.enabled·=·this.DidVote·&&·!this.resultsShowing;235 »       »       this.Flag.enabled·=·this.DidVote·&&·!this.resultsShowing;
236 »       »       this.Overlay.gameObject.SetActive(this.AmDead);236 »       »       this.Overlay.gameObject.SetActive(this.AmDead);
237 »       »       this.Megaphone.enabled·=·this.DidReport;237 »       »       this.Megaphone.enabled·=·this.DidReport;
238 »       }238 »       }
239 239
240 »       public·void·SetCosmetics(GameData.PlayerInfo·playerInfo)240 »       public·void·SetCosmetics(NetworkedPlayerInfo·playerInfo)
241 »       {241 »       {
242 »       »       this.Background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image;242 »       »       this.Background.sprite·=·ShipStatus.Instance.CosmeticsCache.GetNameplate(playerInfo.DefaultOutfit.NamePlateId).Image;
243 »       »       this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null);243 »       »       this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null);
244 »       »       this.PlayerIcon.ToggleName(false);244 »       »       this.PlayerIcon.ToggleName(false);
245 »       »       this.NameText.text·=·playerInfo.PlayerName;245 »       »       this.NameText.text·=·playerInfo.PlayerName;
246 »       »       this.LevelNumberText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel);246 »       »       this.LevelNumberText.text·=·ProgressionManager.FormatVisualLevel(playerInfo.PlayerLevel);
247 »       »       PlayerMaterial.SetColors((int)DataManager.Player.Customization.Color,·this.ThumbsDown);247 »       »       PlayerMaterial.SetColors((int)DataManager.Player.Customization.Color,·this.ThumbsDown);
3.16 KB
Assembly-CSharp/PoolablePlayer.cs
    
Offset 90, 22 lines modifiedOffset 90, 32 lines modified
90 »       }90 »       }
91 91
92 »       public·void·SetMaskLayer(int·layer)92 »       public·void·SetMaskLayer(int·layer)
93 »       {93 »       {
94 »       »       this.cosmetics.SetMaskLayer(layer);94 »       »       this.cosmetics.SetMaskLayer(layer);
95 »       }95 »       }
96 96
97 »       public·void·SetHatAndVisorOnFloor()97 »       public·void·SetHatLeftFacingVictim(bool·leftFacingVictim)
98 »       {98 »       {
 99 »       »       this.cosmetics.SetHatLeftFacingVictim(leftFacingVictim);
 100 »       }
 101
 102 »       public·void·SetHatOnFloor()
 103 »       {
 104 »       »       this.cosmetics.SetHatOnFloor();
 105 »       }
 106
 107 »       public·void·SetVisorOnFloor()
 108 »       {
99 »       »       this.cosmetics.SetHatAndVisorOnFloor();109 »       »       this.cosmetics.SetVisorOnFloor();
100 »       }110 »       }
101 111
102 »       public·void·FlipHatAndVisor()112 »       public·void·FlipHatAndVisor()
103 »       {113 »       {
104 »       »       this.cosmetics.SetHatAndVisorOnFloor();114 »       »       this.cosmetics.SetHatOnFloor();
105 »       }115 »       }
106 116
107 »       public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type)117 »       public·void·SetHatAndVisorMaskType(PlayerMaterial.MaskType·type)
108 »       {118 »       {
109 »       »       this.cosmetics.SetHatAndVisorMaskType(type);119 »       »       this.cosmetics.SetHatAndVisorMaskType(type);
110 »       }120 »       }
111 121
Offset 266, 26 lines modifiedOffset 276, 26 lines modified
266 »       »       {276 »       »       {
267 »       »       »       DataManager.Player.Customization.Visor·=·"visor_EmptyVisor";277 »       »       »       DataManager.Player.Customization.Visor·=·"visor_EmptyVisor";
268 »       »       }278 »       »       }
269 »       »       this.cosmetics.SetVisor(DataManager.Player.Customization.Visor,·(int)DataManager.Player.Customization.Color);279 »       »       this.cosmetics.SetVisor(DataManager.Player.Customization.Visor,·(int)DataManager.Player.Customization.Color);
270 »       »       this.SetColorBlindTag();280 »       »       this.SetColorBlindTag();
271 »       }281 »       }
272 282
273 »       public·void·UpdateFromEitherPlayerDataOrCache(GameData.PlayerInfo·pData,·PlayerOutfitType·outfitType,·PlayerMaterial.MaskType·maskType,·bool·includePet,·Action·OnSkinLoaded·=·null)283 »       public·void·UpdateFromEitherPlayerDataOrCache(NetworkedPlayerInfo·pData,·PlayerOutfitType·outfitType,·PlayerMaterial.MaskType·maskType,·bool·includePet,·Action·OnSkinLoaded·=·null)
274 »       {284 »       {
275 »       »       this.UpdateFromPlayerData(pData,·outfitType,·maskType,·includePet,·OnSkinLoaded,·false);285 »       »       this.UpdateFromPlayerData(pData,·outfitType,·maskType,·includePet,·OnSkinLoaded,·false);
276 »       }286 »       }
277 287
278 »       public·void·UpdateFromPlayerData(GameData.PlayerInfo·pData,·PlayerOutfitType·outfitType,·PlayerMaterial.MaskType·maskType,·bool·includePet,·Action·OnSkinLoaded·=·null,·bool·forceAlive·=·false)288 »       public·void·UpdateFromPlayerData(NetworkedPlayerInfo·pData,·PlayerOutfitType·outfitType,·PlayerMaterial.MaskType·maskType,·bool·includePet,·Action·OnSkinLoaded·=·null,·bool·forceAlive·=·false)
279 »       {289 »       {
280 »       »       GameData.PlayerOutfit·playerOutfit·=·pData.Outfits[outfitType];290 »       »       NetworkedPlayerInfo.PlayerOutfit·playerOutfit·=·pData.Outfits[outfitType];
281 »       »       this.UpdateFromPlayerOutfit(playerOutfit,·maskType,·pData.IsDead,·includePet,·OnSkinLoaded,·forceAlive);291 »       »       this.UpdateFromPlayerOutfit(playerOutfit,·maskType,·pData.IsDead,·includePet,·OnSkinLoaded,·forceAlive);
282 »       }292 »       }
283 293
284 »       public·void·UpdateFromPlayerOutfit(GameData.PlayerOutfit·outfit,·PlayerMaterial.MaskType·maskType,·bool·isDead,·bool·includePet,·Action·OnSkinLoaded·=·null,·bool·forceAlive·=·false)294 »       public·void·UpdateFromPlayerOutfit(NetworkedPlayerInfo.PlayerOutfit·outfit,·PlayerMaterial.MaskType·maskType,·bool·isDead,·bool·includePet,·Action·OnSkinLoaded·=·null,·bool·forceAlive·=·false)
285 »       {295 »       {
286 »       »       this.cosmetics.SetMaskType(maskType);296 »       »       this.cosmetics.SetMaskType(maskType);
287 »       »       this.cosmetics.SetBodyColor(outfit.ColorId);297 »       »       this.cosmetics.SetBodyColor(outfit.ColorId);
288 »       »       this.Hands.ForEach(delegate(SpriteRenderer·b)298 »       »       this.Hands.ForEach(delegate(SpriteRenderer·b)
289 »       »       {299 »       »       {
290 »       »       »       b.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType);300 »       »       »       b.sharedMaterial·=·CosmeticsLayer.GetBodyMaterial(maskType);
291 »       »       »       PlayerMaterial.SetColors(outfit.ColorId,·b);301 »       »       »       PlayerMaterial.SetColors(outfit.ColorId,·b);
Offset 351, 14 lines modifiedOffset 361, 19 lines modified
351 »       }361 »       }
352 362
353 »       public·void·FadeBlackAll(float·duration)363 »       public·void·FadeBlackAll(float·duration)
354 »       {364 »       {
355 »       »       this.cosmetics.FadeBlackCosmetics(duration);365 »       »       this.cosmetics.FadeBlackCosmetics(duration);
356 »       }366 »       }
357 367
 368 »       public·SkinViewData·GetSkinView()
 369 »       {
 370 »       »       return·this.cosmetics.GetSkinView();
 371 »       }
 372
358 »       public·SpriteRenderer[]·Hands;373 »       public·SpriteRenderer[]·Hands;
359 374
360 »       public·SpriteRenderer[]·OtherBodySprites;375 »       public·SpriteRenderer[]·OtherBodySprites;
361 376
362 »       [SerializeField]377 »       [SerializeField]
363 »       private·CosmeticsLayer·cosmetics;378 »       private·CosmeticsLayer·cosmetics;
364 379
2.08 KB
Assembly-CSharp/PowerTools/SpriteAnimNodes.cs
Ordering differences only
    
Offset 143, 72 lines modifiedOffset 143, 72 lines modified
143 »       »       »       this.m_ang7·=·0f;143 »       »       »       this.m_ang7·=·0f;
144 »       »       »       this.m_ang8·=·0f;144 »       »       »       this.m_ang8·=·0f;
145 »       »       »       this.m_ang9·=·0f;145 »       »       »       this.m_ang9·=·0f;
146 »       »       }146 »       »       }
147 147
148 »       »       public·static·readonly·int·NUM_NODES·=·10;148 »       »       public·static·readonly·int·NUM_NODES·=·10;
149 149
150 »       »       [HideInInspector] 
151 »       »       [SerializeField]150 »       »       [SerializeField]
 151 »       »       [HideInInspector]
152 »       »       private·Vector2·m_node0·=·Vector2.zero;152 »       »       private·Vector2·m_node0·=·Vector2.zero;
153 153
154 »       »       [HideInInspector] 
155 »       »       [SerializeField]154 »       »       [SerializeField]
 155 »       »       [HideInInspector]
156 »       »       private·Vector2·m_node1·=·Vector2.zero;156 »       »       private·Vector2·m_node1·=·Vector2.zero;
157 157
158 »       »       [HideInInspector]158 »       »       [HideInInspector]
159 »       »       [SerializeField]159 »       »       [SerializeField]
160 »       »       private·Vector2·m_node2·=·Vector2.zero;160 »       »       private·Vector2·m_node2·=·Vector2.zero;
161 161
162 »       »       [SerializeField]162 »       »       [SerializeField]
163 »       »       [HideInInspector]163 »       »       [HideInInspector]
164 »       »       private·Vector2·m_node3·=·Vector2.zero;164 »       »       private·Vector2·m_node3·=·Vector2.zero;
165 165
166 »       »       [SerializeField]166 »       »       [SerializeField]
167 »       »       [HideInInspector]167 »       »       [HideInInspector]
168 »       »       private·Vector2·m_node4·=·Vector2.zero;168 »       »       private·Vector2·m_node4·=·Vector2.zero;
169 169
170 »       »       [HideInInspector] 
171 »       »       [SerializeField]170 »       »       [SerializeField]
 171 »       »       [HideInInspector]
172 »       »       private·Vector2·m_node5·=·Vector2.zero;172 »       »       private·Vector2·m_node5·=·Vector2.zero;
173 173
174 »       »       [HideInInspector] 
175 »       »       [SerializeField]174 »       »       [SerializeField]
 175 »       »       [HideInInspector]
176 »       »       private·Vector2·m_node6·=·Vector2.zero;176 »       »       private·Vector2·m_node6·=·Vector2.zero;
177 177
178 »       »       [HideInInspector]178 »       »       [HideInInspector]
179 »       »       [SerializeField]179 »       »       [SerializeField]
180 »       »       private·Vector2·m_node7·=·Vector2.zero;180 »       »       private·Vector2·m_node7·=·Vector2.zero;
181 181
182 »       »       [SerializeField] 
183 »       »       [HideInInspector]182 »       »       [HideInInspector]
 183 »       »       [SerializeField]
184 »       »       private·Vector2·m_node8·=·Vector2.zero;184 »       »       private·Vector2·m_node8·=·Vector2.zero;
185 185
186 »       »       [SerializeField]186 »       »       [SerializeField]
187 »       »       [HideInInspector]187 »       »       [HideInInspector]
188 »       »       private·Vector2·m_node9·=·Vector2.zero;188 »       »       private·Vector2·m_node9·=·Vector2.zero;
189 189
190 »       »       [SerializeField] 
191 »       »       [HideInInspector]190 »       »       [HideInInspector]
 191 »       »       [SerializeField]
192 »       »       private·float·m_ang0;192 »       »       private·float·m_ang0;
193 193
194 »       »       [SerializeField] 
195 »       »       [HideInInspector]194 »       »       [HideInInspector]
 195 »       »       [SerializeField]
196 »       »       private·float·m_ang1;196 »       »       private·float·m_ang1;
197 197
198 »       »       [SerializeField] 
199 »       »       [HideInInspector]198 »       »       [HideInInspector]
 199 »       »       [SerializeField]
200 »       »       private·float·m_ang2;200 »       »       private·float·m_ang2;
201 201
202 »       »       [HideInInspector] 
203 »       »       [SerializeField]202 »       »       [SerializeField]
 203 »       »       [HideInInspector]
204 »       »       private·float·m_ang3;204 »       »       private·float·m_ang3;
205 205
206 »       »       [HideInInspector] 
207 »       »       [SerializeField]206 »       »       [SerializeField]
 207 »       »       [HideInInspector]
208 »       »       private·float·m_ang4;208 »       »       private·float·m_ang4;
209 209
210 »       »       [SerializeField]210 »       »       [SerializeField]
211 »       »       [HideInInspector]211 »       »       [HideInInspector]
212 »       »       private·float·m_ang5;212 »       »       private·float·m_ang5;
213 213
214 »       »       [SerializeField]214 »       »       [SerializeField]
Offset 219, 14 lines modifiedOffset 219, 14 lines modified
219 »       »       [HideInInspector]219 »       »       [HideInInspector]
220 »       »       private·float·m_ang7;220 »       »       private·float·m_ang7;
221 221
222 »       »       [HideInInspector]222 »       »       [HideInInspector]
223 »       »       [SerializeField]223 »       »       [SerializeField]
224 »       »       private·float·m_ang8;224 »       »       private·float·m_ang8;
225 225
226 »       »       [SerializeField] 
227 »       »       [HideInInspector]226 »       »       [HideInInspector]
 227 »       »       [SerializeField]
228 »       »       private·float·m_ang9;228 »       »       private·float·m_ang9;
229 229
230 »       »       private·SpriteRenderer·m_spriteRenderer;230 »       »       private·SpriteRenderer·m_spriteRenderer;
231 »       }231 »       }
232 }232 }
6.22 KB
Assembly-CSharp/ProgressionScreen.cs
    
Offset 5, 70 lines modifiedOffset 5, 69 lines modified
5 using·UnityEngine;5 using·UnityEngine;
6 6
7 public·class·ProgressionScreen·:·MonoBehaviour7 public·class·ProgressionScreen·:·MonoBehaviour
8 {8 {
9 »       public·void·Activate()9 »       public·void·Activate()
10 »       {10 »       {
11 »       »       base.gameObject.SetActive(true);11 »       »       base.gameObject.SetActive(true);
12 »       »       ProgressionManager.XpGrantResult·xpGrantedResult·=·TempData.XpGrantedResult;12 »       »       ProgressionManager.XpGrantResult·cachedXpGrantResult·=·EndGameResult.CachedXpGrantResult;
13 »       »       uint·oldLevel·=·xpGrantedResult.OldLevel;13 »       »       uint·oldLevel·=·cachedXpGrantResult.OldLevel;
14 »       »       uint·newLevel·=·xpGrantedResult.NewLevel;14 »       »       uint·newLevel·=·cachedXpGrantResult.NewLevel;
15 »       »       this.XpBar.Value·=·xpGrantedResult.OldXpAmount;15 »       »       this.XpBar.Value·=·cachedXpGrantResult.OldXpAmount;
16 »       »       this.XpBar.CapValue·=·xpGrantedResult.OldXpAmount;16 »       »       this.XpBar.CapValue·=·cachedXpGrantResult.OldXpAmount;
17 »       »       this.XpBar.MaxValue·=·xpGrantedResult.XpRequiredToLevelUp;17 »       »       this.XpBar.MaxValue·=·cachedXpGrantResult.XpRequiredToLevelUp;
18 »       »       this.XpBar.GlowAlpha·=·0f;18 »       »       this.XpBar.GlowAlpha·=·0f;
19 »       »       this.XpEarnedNowText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.XpGainedValue,·new·object[]·{·xpGrantedResult.GrantedXp·});19 »       »       this.XpEarnedNowText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.XpGainedValue,·new·object[]·{·cachedXpGrantResult.GrantedXp·});
20 »       »       this.XpEarnedNowText.color·=·Palette.ClearWhite;20 »       »       this.XpEarnedNowText.color·=·Palette.ClearWhite;
21 »       »       if·(oldLevel·==·xpGrantedResult.MaxLevel)21 »       »       if·(oldLevel·==·cachedXpGrantResult.MaxLevel)
22 »       »       {22 »       »       {
23 »       »       »       this.XpBar.Value·=·1f;23 »       »       »       this.XpBar.Value·=·1f;
24 »       »       »       this.XpBar.CapValue·=·1f;24 »       »       »       this.XpBar.CapValue·=·1f;
25 »       »       »       this.XpBar.MaxValue·=·1f;25 »       »       »       this.XpBar.MaxValue·=·1f;
26 »       »       »       this.LevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>());26 »       »       »       this.LevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>());
27 »       »       »       this.FutureLevelText.color·=·Palette.ClearWhite;27 »       »       »       this.FutureLevelText.color·=·Palette.ClearWhite;
28 »       »       }28 »       »       }
29 »       »       else·if·(newLevel·==·xpGrantedResult.MaxLevel)29 »       »       else·if·(newLevel·==·cachedXpGrantResult.MaxLevel)
30 »       »       {30 »       »       {
31 »       »       »       this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>());31 »       »       »       this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Max,·Array.Empty<object>());
32 »       »       »       this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel);32 »       »       »       this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel);
33 »       »       }33 »       »       }
34 »       »       else34 »       »       else
35 »       »       {35 »       »       {
36 »       »       »       this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel);36 »       »       »       this.LevelText.text·=·ProgressionManager.FormatVisualLevel(oldLevel);
37 »       »       »       string·text·=·ProgressionManager.FormatVisualLevel((newLevel·==·oldLevel)·?·(oldLevel·+·1U)·:·newLevel);37 »       »       »       string·text·=·ProgressionManager.FormatVisualLevel((newLevel·==·oldLevel)·?·(oldLevel·+·1U)·:·newLevel);
38 »       »       »       this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LevelShorthand,·new·object[]·{·text·});38 »       »       »       this.FutureLevelText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.LevelShorthand,·new·object[]·{·text·});
39 »       »       }39 »       »       }
40 »       »       ProgressionManager.CurrencyGrantResult·podsGrantResult·=·TempData.PodsGrantResult;40 »       »       ProgressionManager.CurrencyGrantResult·cachedPodsGrantResult·=·EndGameResult.CachedPodsGrantResult;
41 »       »       CosmicubeData·dataForPodId·=·DestroyableSingleton<CosmicubeManager>.Instance.GetDataForPodId(podsGrantResult.PodId);41 »       »       CosmicubeData·dataForPodId·=·DestroyableSingleton<CosmicubeManager>.Instance.GetDataForPodId(cachedPodsGrantResult.PodId);
42 »       »       if·(!(dataForPodId·==·null)·&&·!(dataForPodId.GetCosmicubeName()·==·"Empty·Cosmicube")·&&·podsGrantResult.GrantedPodsWithMultiplierApplied·>·0U)42 »       »       if·(!(dataForPodId·==·null)·&&·!(dataForPodId.GetCosmicubeName()·==·"Empty·Cosmicube")·&&·cachedPodsGrantResult.GrantedPodsWithMultiplierApplied·>·0U)
43 »       »       {43 »       »       {
44 »       »       »       this.PodsEarned.Initialize(podsGrantResult);44 »       »       »       this.PodsEarned.Initialize(cachedPodsGrantResult);
45 »       »       }45 »       »       }
46 »       »       else46 »       »       else
47 »       »       {47 »       »       {
48 »       »       »       this.PodsEarned.gameObject.SetActive(false);48 »       »       »       this.PodsEarned.gameObject.SetActive(false);
49 »       »       }49 »       »       }
50 »       »       ProgressionManager.CurrencyGrantResult·beansGrantResult·=·TempData.BeansGrantResult;50 »       »       ProgressionManager.CurrencyGrantResult·cachedBeansGrantResult·=·EndGameResult.CachedBeansGrantResult;
51 »       »       if·(beansGrantResult.GrantedPodsWithMultiplierApplied·>·0U)51 »       »       if·(cachedBeansGrantResult.GrantedPodsWithMultiplierApplied·>·0U)
52 »       »       {52 »       »       {
53 »       »       »       this.BeansEarned.Initialize(beansGrantResult);53 »       »       »       this.BeansEarned.Initialize(cachedBeansGrantResult);
54 »       »       }54 »       »       }
55 »       »       else55 »       »       else
56 »       »       {56 »       »       {
57 »       »       »       this.BeansEarned.gameObject.SetActive(false);57 »       »       »       this.BeansEarned.gameObject.SetActive(false);
58 »       »       }58 »       »       }
59 »       »       if·(this.BeansEarned.gameObject.activeSelf·!=·this.PodsEarned.gameObject.activeSelf)59 »       »       if·(this.BeansEarned.gameObject.activeSelf·!=·this.PodsEarned.gameObject.activeSelf)
60 »       »       {60 »       »       {
61 »       »       »       Transform·transform·=·(this.BeansEarned.gameObject.activeSelf·?·this.BeansEarned.transform·:·this.PodsEarned.transform);61 »       »       »       Transform·transform·=·(this.BeansEarned.gameObject.activeSelf·?·this.BeansEarned.transform·:·this.PodsEarned.transform);
62 »       »       »       transform.localPosition·=·new·Vector3(0f,·transform.localPosition.y,·base.transform.localPosition.z);62 »       »       »       transform.localPosition·=·new·Vector3(0f,·transform.localPosition.y,·base.transform.localPosition.z);
63 »       »       }63 »       »       }
 64 »       »       this.Player.UpdateFromPlayerOutfit(EndGameResult.CachedLocalPlayer.Outfit,·PlayerMaterial.MaskType.None,·false,·true,·null,·false);
64 »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data; 
65 »       »       this.Player.UpdateFromEitherPlayerDataOrCache(data,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.None,·true,·null); 
66 »       »       this.Player.ToggleName(false);65 »       »       this.Player.ToggleName(false);
67 »       »       base.StartCoroutine(this.DoAnimations(xpGrantedResult));66 »       »       base.StartCoroutine(this.DoAnimations(cachedXpGrantResult));
68 »       }67 »       }
69 68
70 »       private·IEnumerator·DoAnimations(ProgressionManager.XpGrantResult·xpGainedResult)69 »       private·IEnumerator·DoAnimations(ProgressionManager.XpGrantResult·xpGainedResult)
71 »       {70 »       {
72 »       »       yield·return·Effects.Wait(0.2f);71 »       »       yield·return·Effects.Wait(0.2f);
73 »       »       if·((xpGainedResult.MaxLevel·!=·DataManager.Player.Stats.Level·||·xpGainedResult.OldLevel·!=·xpGainedResult.NewLevel)·&&·xpGainedResult.GrantedXp·>·0U)72 »       »       if·((xpGainedResult.MaxLevel·!=·DataManager.Player.Stats.Level·||·xpGainedResult.OldLevel·!=·xpGainedResult.NewLevel)·&&·xpGainedResult.GrantedXp·>·0U)
74 »       »       {73 »       »       {
Offset 186, 25 lines modifiedOffset 185, 25 lines modified
186 »       »       }185 »       »       }
187 »       »       if·(this.PodsEarned.gameObject.activeSelf)186 »       »       if·(this.PodsEarned.gameObject.activeSelf)
188 »       »       {187 »       »       {
189 »       »       »       yield·return·this.PodsEarned.ShowAmount();188 »       »       »       yield·return·this.PodsEarned.ShowAmount();
190 »       »       }189 »       »       }
191 »       »       if·(this.BeansEarned.gameObject.activeSelf)190 »       »       if·(this.BeansEarned.gameObject.activeSelf)
192 »       »       {191 »       »       {
193 »       »       »       ProgressionManager.CurrencyGrantResult·beansGrantResult·=·TempData.BeansGrantResult;192 »       »       »       ProgressionManager.CurrencyGrantResult·cachedBeansGrantResult·=·EndGameResult.CachedBeansGrantResult;
194 »       »       »       if·(beansGrantResult.GrantedPodsWithMultiplierApplied·!=·beansGrantResult.GrantedPodsPreMultiplier)193 »       »       »       if·(cachedBeansGrantResult.GrantedPodsWithMultiplierApplied·!=·cachedBeansGrantResult.GrantedPodsPreMultiplier)
195 »       »       »       {194 »       »       »       {
196 »       »       »       »       yield·return·this.BeansEarned.ShowMultiplier();195 »       »       »       »       yield·return·this.BeansEarned.ShowMultiplier();
197 »       »       »       }196 »       »       »       }
198 »       »       »       base.StartCoroutine(this.BeansEarned.EnterWallet());197 »       »       »       base.StartCoroutine(this.BeansEarned.EnterWallet());
199 »       »       }198 »       »       }
200 »       »       if·(this.PodsEarned.gameObject.activeSelf)199 »       »       if·(this.PodsEarned.gameObject.activeSelf)
201 »       »       {200 »       »       {
202 »       »       »       ProgressionManager.CurrencyGrantResult·podsGrantResult·=·TempData.PodsGrantResult;201 »       »       »       ProgressionManager.CurrencyGrantResult·cachedPodsGrantResult·=·EndGameResult.CachedPodsGrantResult;
203 »       »       »       if·(podsGrantResult.GrantedPodsWithMultiplierApplied·!=·podsGrantResult.GrantedPodsPreMultiplier)202 »       »       »       if·(cachedPodsGrantResult.GrantedPodsWithMultiplierApplied·!=·cachedPodsGrantResult.GrantedPodsPreMultiplier)
204 »       »       »       {203 »       »       »       {
205 »       »       »       »       yield·return·this.PodsEarned.ShowMultiplier();204 »       »       »       »       yield·return·this.PodsEarned.ShowMultiplier();
206 »       »       »       }205 »       »       »       }
207 »       »       »       base.StartCoroutine(this.PodsEarned.EnterWallet());206 »       »       »       base.StartCoroutine(this.PodsEarned.EnterWallet());
208 »       »       }207 »       »       }
209 »       »       yield·break;208 »       »       yield·break;
210 »       }209 »       }
805 B
Assembly-CSharp/ProgressTracker.cs
    
Offset 25, 15 lines modifiedOffset 25, 15 lines modified
25 »       »       {25 »       »       {
26 »       »       »       this.TileParent.enabled·=·true;26 »       »       »       this.TileParent.enabled·=·true;
27 »       »       }27 »       »       }
28 »       »       GameData·instance·=·GameData.Instance;28 »       »       GameData·instance·=·GameData.Instance;
29 »       »       if·(instance·&&·instance.TotalTasks·>·0)29 »       »       if·(instance·&&·instance.TotalTasks·>·0)
30 »       »       {30 »       »       {
31 »       »       »       int·num·=·(DestroyableSingleton<TutorialManager>.InstanceExists·?·1·:·(instance.AllPlayers.Count·-·GameManager.Instance.LogicOptions.NumImpostors));31 »       »       »       int·num·=·(DestroyableSingleton<TutorialManager>.InstanceExists·?·1·:·(instance.AllPlayers.Count·-·GameManager.Instance.LogicOptions.NumImpostors));
32 »       »       »       num·-=·Enumerable.Count<GameData.PlayerInfo>(instance.AllPlayers,·(GameData.PlayerInfo·p)·=>·p.Disconnected);32 »       »       »       num·-=·Enumerable.Count<NetworkedPlayerInfo>(instance.AllPlayers,·(NetworkedPlayerInfo·p)·=>·p.Disconnected);
33 »       »       »       switch·(GameManager.Instance.LogicOptions.GetTaskBarMode())33 »       »       »       switch·(GameManager.Instance.LogicOptions.GetTaskBarMode())
34 »       »       »       {34 »       »       »       {
35 »       »       »       case·TaskBarMode.Normal:35 »       »       »       case·TaskBarMode.Normal:
36 »       »       »       »       break;36 »       »       »       »       break;
37 »       »       »       case·TaskBarMode.MeetingOnly:37 »       »       »       case·TaskBarMode.MeetingOnly:
38 »       »       »       »       if·(!MeetingHud.Instance)38 »       »       »       »       if·(!MeetingHud.Instance)
39 »       »       »       »       {39 »       »       »       »       {
901 B
Assembly-CSharp/PurchaseButton.cs
    
Offset 1, 8 lines modifiedOffset 1, 9 lines modified
1 using·System;1 using·System;
 2 using·AmongUs.Data;
2 using·Assets.InnerNet;3 using·Assets.InnerNet;
3 using·Innersloth.Assets;4 using·Innersloth.Assets;
4 using·TMPro;5 using·TMPro;
5 using·UnityEngine;6 using·UnityEngine;
6 7
7 public·class·PurchaseButton·:·MonoBehaviour8 public·class·PurchaseButton·:·MonoBehaviour
8 {9 {
Offset 141, 15 lines modifiedOffset 142, 15 lines modified
141 »       »       »       this.SetSquare();142 »       »       »       this.SetSquare();
142 »       »       »       return;143 »       »       »       return;
143 »       »       }144 »       »       }
144 »       »       if·(this.Product·is·PetData)145 »       »       if·(this.Product·is·PetData)
145 »       »       {146 »       »       {
146 »       »       »       PetData·petData·=·(PetData)this.Product;147 »       »       »       PetData·petData·=·(PetData)this.Product;
147 »       »       »       this.CrewHeadImage.enabled·=·false;148 »       »       »       this.CrewHeadImage.enabled·=·false;
148 »       »       »       this.HatImage.FrontLayer.sprite·=·petData.SpritePreview;149 »       »       »       petData.SetPreview(this.HatImage.FrontLayer,·(int)DataManager.Player.Customization.Color);
149 »       »       »       this.HatImage.FrontLayer.transform.localPosition·=·new·Vector3(0f,·0.35f,·-0.01f);150 »       »       »       this.HatImage.FrontLayer.transform.localPosition·=·new·Vector3(0f,·0.35f,·-0.01f);
150 »       »       »       this.HatImage.FrontLayer.transform.localScale·=·Vector3.one·*·0.5f;151 »       »       »       this.HatImage.FrontLayer.transform.localScale·=·Vector3.one·*·0.5f;
151 »       »       »       this.NameText.text·=·petData.GetItemName();152 »       »       »       this.NameText.text·=·petData.GetItemName();
152 »       »       »       this.SetSquare();153 »       »       »       this.SetSquare();
153 »       »       »       return;154 »       »       »       return;
154 »       »       }155 »       »       }
155 »       »       if·(this.Product·is·CosmicubeData)156 »       »       if·(this.Product·is·CosmicubeData)
555 B
Assembly-CSharp/RadialMenu.cs
Ordering differences only
    
Offset 1, 15 lines modifiedOffset 1, 15 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·Rewired;3 using·Rewired;
4 using·TMPro;4 using·TMPro;
5 using·UnityEngine;5 using·UnityEngine;
6 6
7 [RequireComponent(typeof(MeshRenderer))] 
8 [RequireComponent(typeof(MeshFilter))]7 [RequireComponent(typeof(MeshFilter))]
 8 [RequireComponent(typeof(MeshRenderer))]
9 public·class·RadialMenu·:·MonoBehaviour9 public·class·RadialMenu·:·MonoBehaviour
10 {10 {
11 »       private·void·OnEnable()11 »       private·void·OnEnable()
12 »       {12 »       {
13 »       »       this.mf·=·base.GetComponent<MeshFilter>();13 »       »       this.mf·=·base.GetComponent<MeshFilter>();
14 »       »       this.mr·=·base.GetComponent<MeshRenderer>();14 »       »       this.mr·=·base.GetComponent<MeshRenderer>();
15 »       »       this.mbp·=·new·MaterialPropertyBlock();15 »       »       this.mbp·=·new·MaterialPropertyBlock();
1.59 KB
Assembly-CSharp/Rewired/Data/UserDataStore_PlayerPrefs.cs
Ordering differences only
    
Offset 1238, 32 lines modifiedOffset 1238, 32 lines modified
1238 1238
1239 »       »       private·const·int·controllerMapPPKeyVersion·=·2;1239 »       »       private·const·int·controllerMapPPKeyVersion·=·2;
1240 1240
1241 »       »       [SerializeField]1241 »       »       [SerializeField]
1242 »       »       [Tooltip("Should·this·script·be·used?·If·disabled,·nothing·will·be·saved·or·loaded.")]1242 »       »       [Tooltip("Should·this·script·be·used?·If·disabled,·nothing·will·be·saved·or·loaded.")]
1243 »       »       private·bool·isEnabled·=·true;1243 »       »       private·bool·isEnabled·=·true;
1244 1244
1245 »       »       [SerializeField] 
1246 »       »       [Tooltip("Should·saved·data·be·loaded·on·start?")]1245 »       »       [Tooltip("Should·saved·data·be·loaded·on·start?")]
 1246 »       »       [SerializeField]
1247 »       »       private·bool·loadDataOnStart·=·true;1247 »       »       private·bool·loadDataOnStart·=·true;
1248 1248
1249 »       »       [SerializeField]1249 »       »       [SerializeField]
1250 »       »       [Tooltip("Should·Player·Joystick·assignments·be·saved·and·loaded?·This·is·not·totally·reliable·for·all·Joysticks·on·all·platforms.·Some·platforms/input·sources·do·not·provide·enough·information·to·reliably·save·assignments·from·session·to·session·and·reboot·to·reboot.")]1250 »       »       [Tooltip("Should·Player·Joystick·assignments·be·saved·and·loaded?·This·is·not·totally·reliable·for·all·Joysticks·on·all·platforms.·Some·platforms/input·sources·do·not·provide·enough·information·to·reliably·save·assignments·from·session·to·session·and·reboot·to·reboot.")]
1251 »       »       private·bool·loadJoystickAssignments·=·true;1251 »       »       private·bool·loadJoystickAssignments·=·true;
1252 1252
1253 »       »       [SerializeField] 
1254 »       »       [Tooltip("Should·Player·Keyboard·assignments·be·saved·and·loaded?")]1253 »       »       [Tooltip("Should·Player·Keyboard·assignments·be·saved·and·loaded?")]
 1254 »       »       [SerializeField]
1255 »       »       private·bool·loadKeyboardAssignments·=·true;1255 »       »       private·bool·loadKeyboardAssignments·=·true;
1256 1256
1257 »       »       [Tooltip("Should·Player·Mouse·assignments·be·saved·and·loaded?")]1257 »       »       [Tooltip("Should·Player·Mouse·assignments·be·saved·and·loaded?")]
1258 »       »       [SerializeField]1258 »       »       [SerializeField]
1259 »       »       private·bool·loadMouseAssignments·=·true;1259 »       »       private·bool·loadMouseAssignments·=·true;
1260 1260
1261 »       »       [SerializeField] 
1262 »       »       [Tooltip("The·PlayerPrefs·key·prefix.·Change·this·to·change·how·keys·are·stored·in·PlayerPrefs.·Changing·this·will·make·saved·data·already·stored·with·the·old·key·no·longer·accessible.")]1261 »       »       [Tooltip("The·PlayerPrefs·key·prefix.·Change·this·to·change·how·keys·are·stored·in·PlayerPrefs.·Changing·this·will·make·saved·data·already·stored·with·the·old·key·no·longer·accessible.")]
 1262 »       »       [SerializeField]
1263 »       »       private·string·playerPrefsKeyPrefix·=·"RewiredSaveData";1263 »       »       private·string·playerPrefsKeyPrefix·=·"RewiredSaveData";
1264 1264
1265 »       »       [NonSerialized]1265 »       »       [NonSerialized]
1266 »       »       private·bool·allowImpreciseJoystickAssignmentMatching·=·true;1266 »       »       private·bool·allowImpreciseJoystickAssignmentMatching·=·true;
1267 1267
1268 »       »       [NonSerialized]1268 »       »       [NonSerialized]
1269 »       »       private·bool·deferredJoystickAssignmentLoadPending;1269 »       »       private·bool·deferredJoystickAssignmentLoadPending;
511 B
Assembly-CSharp/Rewired/Demos/PressAnyButtonToJoinExample_GamePlayer.cs
Ordering differences only
    
Offset 1, 14 lines modifiedOffset 1, 14 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 namespace·Rewired.Demos4 namespace·Rewired.Demos
5 {5 {
6 »       [AddComponentMenu("")] 
7 »       [RequireComponent(typeof(CharacterController))]6 »       [RequireComponent(typeof(CharacterController))]
 7 »       [AddComponentMenu("")]
8 »       public·class·PressAnyButtonToJoinExample_GamePlayer·:·MonoBehaviour8 »       public·class·PressAnyButtonToJoinExample_GamePlayer·:·MonoBehaviour
9 »       {9 »       {
10 »       »       private·Player·player10 »       »       private·Player·player
11 »       »       {11 »       »       {
12 »       »       »       get12 »       »       »       get
13 »       »       »       {13 »       »       »       {
14 »       »       »       »       if·(!ReInput.isReady)14 »       »       »       »       if·(!ReInput.isReady)
554 B
Assembly-CSharp/Rewired/Demos/PressStartToJoinExample_GamePlayer.cs
Ordering differences only
    
Offset 1, 14 lines modifiedOffset 1, 14 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 namespace·Rewired.Demos4 namespace·Rewired.Demos
5 {5 {
6 »       [AddComponentMenu("")] 
7 »       [RequireComponent(typeof(CharacterController))]6 »       [RequireComponent(typeof(CharacterController))]
 7 »       [AddComponentMenu("")]
8 »       public·class·PressStartToJoinExample_GamePlayer·:·MonoBehaviour8 »       public·class·PressStartToJoinExample_GamePlayer·:·MonoBehaviour
9 »       {9 »       {
10 »       »       private·Player·player10 »       »       private·Player·player
11 »       »       {11 »       »       {
12 »       »       »       get12 »       »       »       get
13 »       »       »       {13 »       »       »       {
14 »       »       »       »       return·PressStartToJoinExample_Assigner.GetRewiredPlayer(this.gamePlayerId);14 »       »       »       »       return·PressStartToJoinExample_Assigner.GetRewiredPlayer(this.gamePlayerId);
500 B
Assembly-CSharp/Rewired/Demos/UIPointer.cs
Ordering differences only
    
Offset 1, 16 lines modifiedOffset 1, 16 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 using·UnityEngine.EventSystems;3 using·UnityEngine.EventSystems;
4 using·UnityEngine.UI;4 using·UnityEngine.UI;
5 5
6 namespace·Rewired.Demos6 namespace·Rewired.Demos
7 {7 {
8 »       [RequireComponent(typeof(RectTransform))] 
9 »       [AddComponentMenu("")]8 »       [AddComponentMenu("")]
 9 »       [RequireComponent(typeof(RectTransform))]
10 »       public·sealed·class·UIPointer·:·UIBehaviour10 »       public·sealed·class·UIPointer·:·UIBehaviour
11 »       {11 »       {
12 »       »       public·bool·autoSort12 »       »       public·bool·autoSort
13 »       »       {13 »       »       {
14 »       »       »       get14 »       »       »       get
15 »       »       »       {15 »       »       »       {
16 »       »       »       »       return·this._autoSort;16 »       »       »       »       return·this._autoSort;
557 B
Assembly-CSharp/Rewired/InputManager.cs
Ordering differences only
    
Offset 4, 16 lines modifiedOffset 4, 16 lines modified
4 using·Rewired.Utils;4 using·Rewired.Utils;
5 using·Rewired.Utils.Interfaces;5 using·Rewired.Utils.Interfaces;
6 using·UnityEngine;6 using·UnityEngine;
7 using·UnityEngine.SceneManagement;7 using·UnityEngine.SceneManagement;
8 8
9 namespace·Rewired9 namespace·Rewired
10 {10 {
11 »       [EditorBrowsable(EditorBrowsableState.Never)] 
12 »       [AddComponentMenu("Rewired/Input·Manager")]11 »       [AddComponentMenu("Rewired/Input·Manager")]
 12 »       [EditorBrowsable(EditorBrowsableState.Never)]
13 »       public·sealed·class·InputManager·:·InputManager_Base13 »       public·sealed·class·InputManager·:·InputManager_Base
14 »       {14 »       {
15 »       »       protected·override·void·OnInitialized()15 »       »       protected·override·void·OnInitialized()
16 »       »       {16 »       »       {
17 »       »       »       this.SubscribeEvents();17 »       »       »       this.SubscribeEvents();
18 »       »       }18 »       »       }
19 19
518 B
Assembly-CSharp/Rewired/Integration/UnityUI/RewiredEventSystem.cs
Ordering differences only
    
Offset 40, 12 lines modifiedOffset 40, 12 lines modified
40 »       »       »       »       »       »       EventSystem.current·=·current;40 »       »       »       »       »       »       EventSystem.current·=·current;
41 »       »       »       »       »       }41 »       »       »       »       »       }
42 »       »       »       »       }42 »       »       »       »       }
43 »       »       »       }43 »       »       »       }
44 »       »       »       base.Update();44 »       »       »       base.Update();
45 »       »       }45 »       »       }
46 46
47 »       »       [SerializeField] 
48 »       »       [Tooltip("If·enabled,·the·Event·System·will·be·updated·every·frame·even·if·other·Event·Systems·are·enabled.·Otherwise,·only·EventSystem.current·will·be·updated.")]47 »       »       [Tooltip("If·enabled,·the·Event·System·will·be·updated·every·frame·even·if·other·Event·Systems·are·enabled.·Otherwise,·only·EventSystem.current·will·be·updated.")]
 48 »       »       [SerializeField]
49 »       »       private·bool·_alwaysUpdate;49 »       »       private·bool·_alwaysUpdate;
50 »       }50 »       }
51 }51 }
3.98 KB
Assembly-CSharp/Rewired/Integration/UnityUI/RewiredStandaloneInputModule.cs
Ordering differences only
    
Offset 1281, 36 lines modifiedOffset 1281, 36 lines modified
1281 1281
1282 »       »       private·const·string·DEFAULT_ACTION_CANCEL·=·"UICancel";1282 »       »       private·const·string·DEFAULT_ACTION_CANCEL·=·"UICancel";
1283 1283
1284 »       »       [Tooltip("(Optional)·Link·the·Rewired·Input·Manager·here·for·easier·access·to·Player·ids,·etc.")]1284 »       »       [Tooltip("(Optional)·Link·the·Rewired·Input·Manager·here·for·easier·access·to·Player·ids,·etc.")]
1285 »       »       [SerializeField]1285 »       »       [SerializeField]
1286 »       »       private·InputManager_Base·rewiredInputManager;1286 »       »       private·InputManager_Base·rewiredInputManager;
1287 1287
1288 »       »       [SerializeField] 
1289 »       »       [Tooltip("Use·all·Rewired·game·Players·to·control·the·UI.·This·does·not·include·the·System·Player.·If·enabled,·this·setting·overrides·individual·Player·Ids·set·in·Rewired·Player·Ids.")]1288 »       »       [Tooltip("Use·all·Rewired·game·Players·to·control·the·UI.·This·does·not·include·the·System·Player.·If·enabled,·this·setting·overrides·individual·Player·Ids·set·in·Rewired·Player·Ids.")]
 1289 »       »       [SerializeField]
1290 »       »       private·bool·useAllRewiredGamePlayers;1290 »       »       private·bool·useAllRewiredGamePlayers;
1291 1291
1292 »       »       [Tooltip("Allow·the·Rewired·System·Player·to·control·the·UI.")] 
1293 »       »       [SerializeField]1292 »       »       [SerializeField]
 1293 »       »       [Tooltip("Allow·the·Rewired·System·Player·to·control·the·UI.")]
1294 »       »       private·bool·useRewiredSystemPlayer;1294 »       »       private·bool·useRewiredSystemPlayer;
1295 1295
1296 »       »       [Tooltip("A·list·of·Player·Ids·that·are·allowed·to·control·the·UI.·If·Use·All·Rewired·Game·Players·=·True,·this·list·will·be·ignored.")]1296 »       »       [Tooltip("A·list·of·Player·Ids·that·are·allowed·to·control·the·UI.·If·Use·All·Rewired·Game·Players·=·True,·this·list·will·be·ignored.")]
1297 »       »       [SerializeField]1297 »       »       [SerializeField]
1298 »       »       private·int[]·rewiredPlayerIds·=·new·int[1];1298 »       »       private·int[]·rewiredPlayerIds·=·new·int[1];
1299 1299
1300 »       »       [SerializeField] 
1301 »       »       [Tooltip("Allow·only·Players·with·Player.isPlaying·=·true·to·control·the·UI.")]1300 »       »       [Tooltip("Allow·only·Players·with·Player.isPlaying·=·true·to·control·the·UI.")]
 1301 »       »       [SerializeField]
1302 »       »       private·bool·usePlayingPlayersOnly;1302 »       »       private·bool·usePlayingPlayersOnly;
1303 1303
1304 »       »       [Tooltip("Player·Mice·allowed·to·interact·with·the·UI.·Each·Player·that·owns·a·Player·Mouse·must·also·be·allowed·to·control·the·UI·or·the·Player·Mouse·will·not·function.")]1304 »       »       [Tooltip("Player·Mice·allowed·to·interact·with·the·UI.·Each·Player·that·owns·a·Player·Mouse·must·also·be·allowed·to·control·the·UI·or·the·Player·Mouse·will·not·function.")]
1305 »       »       [SerializeField]1305 »       »       [SerializeField]
1306 »       »       private·List<PlayerMouse>·playerMice·=·new·List<PlayerMouse>();1306 »       »       private·List<PlayerMouse>·playerMice·=·new·List<PlayerMouse>();
1307 1307
1308 »       »       [Tooltip("Makes·an·axis·press·always·move·only·one·UI·selection.·Enable·if·you·do·not·want·to·allow·scrolling·through·UI·elements·by·holding·an·axis·direction.")] 
1309 »       »       [SerializeField]1308 »       »       [SerializeField]
 1309 »       »       [Tooltip("Makes·an·axis·press·always·move·only·one·UI·selection.·Enable·if·you·do·not·want·to·allow·scrolling·through·UI·elements·by·holding·an·axis·direction.")]
1310 »       »       private·bool·moveOneElementPerAxisPress;1310 »       »       private·bool·moveOneElementPerAxisPress;
1311 1311
1312 »       »       [Tooltip("If·enabled,·Action·Ids·will·be·used·to·set·the·Actions.·If·disabled,·string·names·will·be·used·to·set·the·Actions.")]1312 »       »       [Tooltip("If·enabled,·Action·Ids·will·be·used·to·set·the·Actions.·If·disabled,·string·names·will·be·used·to·set·the·Actions.")]
1313 »       »       [SerializeField]1313 »       »       [SerializeField]
1314 »       »       private·bool·setActionsById;1314 »       »       private·bool·setActionsById;
1315 1315
1316 »       »       [SerializeField]1316 »       »       [SerializeField]
Offset 1321, 16 lines modifiedOffset 1321, 16 lines modified
1321 »       »       [Tooltip("Id·of·the·vertical·Action·for·movement·(if·axis·events·are·used).")]1321 »       »       [Tooltip("Id·of·the·vertical·Action·for·movement·(if·axis·events·are·used).")]
1322 »       »       private·int·verticalActionId·=·-1;1322 »       »       private·int·verticalActionId·=·-1;
1323 1323
1324 »       »       [SerializeField]1324 »       »       [SerializeField]
1325 »       »       [Tooltip("Id·of·the·Action·used·to·submit.")]1325 »       »       [Tooltip("Id·of·the·Action·used·to·submit.")]
1326 »       »       private·int·submitActionId·=·-1;1326 »       »       private·int·submitActionId·=·-1;
1327 1327
1328 »       »       [Tooltip("Id·of·the·Action·used·to·cancel.")] 
1329 »       »       [SerializeField]1328 »       »       [SerializeField]
 1329 »       »       [Tooltip("Id·of·the·Action·used·to·cancel.")]
1330 »       »       private·int·cancelActionId·=·-1;1330 »       »       private·int·cancelActionId·=·-1;
1331 1331
1332 »       »       [Tooltip("Name·of·the·horizontal·axis·for·movement·(if·axis·events·are·used).")]1332 »       »       [Tooltip("Name·of·the·horizontal·axis·for·movement·(if·axis·events·are·used).")]
1333 »       »       [SerializeField]1333 »       »       [SerializeField]
1334 »       »       private·string·m_HorizontalAxis·=·"UIHorizontal";1334 »       »       private·string·m_HorizontalAxis·=·"UIHorizontal";
1335 1335
1336 »       »       [SerializeField]1336 »       »       [SerializeField]
Offset 1353, 33 lines modifiedOffset 1353, 33 lines modified
1353 »       »       [SerializeField]1353 »       »       [SerializeField]
1354 »       »       private·float·m_RepeatDelay;1354 »       »       private·float·m_RepeatDelay;
1355 1355
1356 »       »       [SerializeField]1356 »       »       [SerializeField]
1357 »       »       [Tooltip("Allows·the·mouse·to·be·used·to·select·elements.")]1357 »       »       [Tooltip("Allows·the·mouse·to·be·used·to·select·elements.")]
1358 »       »       private·bool·m_allowMouseInput·=·true;1358 »       »       private·bool·m_allowMouseInput·=·true;
1359 1359
1360 »       »       [SerializeField] 
1361 »       »       [Tooltip("Allows·the·mouse·to·be·used·to·select·elements·if·the·device·also·supports·touch·control.")]1360 »       »       [Tooltip("Allows·the·mouse·to·be·used·to·select·elements·if·the·device·also·supports·touch·control.")]
 1361 »       »       [SerializeField]
1362 »       »       private·bool·m_allowMouseInputIfTouchSupported·=·true;1362 »       »       private·bool·m_allowMouseInputIfTouchSupported·=·true;
1363 1363
1364 »       »       [SerializeField] 
1365 »       »       [Tooltip("Allows·touch·input·to·be·used·to·select·elements.")]1364 »       »       [Tooltip("Allows·touch·input·to·be·used·to·select·elements.")]
 1365 »       »       [SerializeField]
1366 »       »       private·bool·m_allowTouchInput·=·true;1366 »       »       private·bool·m_allowTouchInput·=·true;
1367 1367
1368 »       »       [SerializeField] 
1369 »       »       [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·when·the·pointer·is·not·over·a·selectable·object.")]1368 »       »       [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·when·the·pointer·is·not·over·a·selectable·object.")]
 1369 »       »       [SerializeField]
1370 »       »       private·bool·m_deselectIfBackgroundClicked·=·true;1370 »       »       private·bool·m_deselectIfBackgroundClicked·=·true;
1371 1371
1372 »       »       [SerializeField] 
1373 »       »       [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·before·selecting·the·next·object.")]1372 »       »       [Tooltip("Deselects·the·current·selection·on·mouse/touch·click·before·selecting·the·next·object.")]
 1373 »       »       [SerializeField]
1374 »       »       private·bool·m_deselectBeforeSelecting·=·true;1374 »       »       private·bool·m_deselectBeforeSelecting·=·true;
1375 1375
1376 »       »       [Tooltip("Forces·the·module·to·always·be·active.")]1376 »       »       [Tooltip("Forces·the·module·to·always·be·active.")]
1377 »       »       [SerializeField] 
1378 »       »       [FormerlySerializedAs("m_AllowActivationOnMobileDevice")]1377 »       »       [FormerlySerializedAs("m_AllowActivationOnMobileDevice")]
 1378 »       »       [SerializeField]
1379 »       »       private·bool·m_ForceModuleActive;1379 »       »       private·bool·m_ForceModuleActive;
1380 1380
1381 »       »       [NonSerialized]1381 »       »       [NonSerialized]
1382 »       »       private·int[]·playerIds;1382 »       »       private·int[]·playerIds;
1383 1383
1384 »       »       private·bool·recompiling;1384 »       »       private·bool·recompiling;
1385 1385
1.3 KB
Assembly-CSharp/Rewired/Platforms/Switch/NintendoSwitchInputManager.cs
Ordering differences only
    
Offset 493, 16 lines modifiedOffset 493, 16 lines modified
493 »       »       »       »       {493 »       »       »       »       {
494 »       »       »       »       »       return·false;494 »       »       »       »       »       return·false;
495 »       »       »       »       }495 »       »       »       »       }
496 »       »       »       »       action(value);496 »       »       »       »       action(value);
497 »       »       »       »       return·true;497 »       »       »       »       return·true;
498 »       »       »       }498 »       »       »       }
499 499
500 »       »       »       [Tooltip("Determines·whether·this·Npad·id·is·allowed·to·be·used·by·the·system.")] 
501 »       »       »       [SerializeField]500 »       »       »       [SerializeField]
 501 »       »       »       [Tooltip("Determines·whether·this·Npad·id·is·allowed·to·be·used·by·the·system.")]
502 »       »       »       private·bool·_isAllowed·=·true;502 »       »       »       private·bool·_isAllowed·=·true;
503 503
504 »       »       »       [Tooltip("The·Rewired·Player·Id·assigned·to·this·Npad·id.")]504 »       »       »       [Tooltip("The·Rewired·Player·Id·assigned·to·this·Npad·id.")]
505 »       »       »       [SerializeField]505 »       »       »       [SerializeField]
506 »       »       »       private·int·_rewiredPlayerId;506 »       »       »       private·int·_rewiredPlayerId;
507 507
508 »       »       »       [Tooltip("Determines·how·Joy-Cons·should·be·handled.\n\nUnmodified:·Joy-Con·assignment·mode·will·be·left·at·the·system·default.\nDual:·Joy-Cons·pairs·are·handled·as·a·single·controller.\nSingle:·Joy-Cons·are·handled·as·individual·controllers.")]508 »       »       »       [Tooltip("Determines·how·Joy-Cons·should·be·handled.\n\nUnmodified:·Joy-Con·assignment·mode·will·be·left·at·the·system·default.\nDual:·Joy-Cons·pairs·are·handled·as·a·single·controller.\nSingle:·Joy-Cons·are·handled·as·individual·controllers.")]
Offset 610, 16 lines modifiedOffset 610, 16 lines modified
610 »       »       »       »       {610 »       »       »       »       {
611 »       »       »       »       »       return·false;611 »       »       »       »       »       return·false;
612 »       »       »       »       }612 »       »       »       »       }
613 »       »       »       »       action(value);613 »       »       »       »       action(value);
614 »       »       »       »       return·true;614 »       »       »       »       return·true;
615 »       »       »       }615 »       »       »       }
616 616
617 »       »       »       [SerializeField] 
618 »       »       »       [Tooltip("Determines·whether·the·Debug·Pad·will·be·enabled.")]617 »       »       »       [Tooltip("Determines·whether·the·Debug·Pad·will·be·enabled.")]
 618 »       »       »       [SerializeField]
619 »       »       »       private·bool·_enabled;619 »       »       »       private·bool·_enabled;
620 620
621 »       »       »       [Tooltip("The·Rewired·Player·Id·to·which·the·Debug·Pad·will·be·assigned.")]621 »       »       »       [Tooltip("The·Rewired·Player·Id·to·which·the·Debug·Pad·will·be·assigned.")]
622 »       »       »       [SerializeField]622 »       »       »       [SerializeField]
623 »       »       »       private·int·_rewiredPlayerId;623 »       »       »       private·int·_rewiredPlayerId;
624 624
625 »       »       »       private·Dictionary<int,·object[]>·__delegates;625 »       »       »       private·Dictionary<int,·object[]>·__delegates;
16.1 KB
Assembly-CSharp/Rewired/UI/ControlMapper/ControlMapper.cs
Ordering differences only
    
Offset 4319, 95 lines modifiedOffset 4319, 95 lines modified
4319 4319
4320 »       »       private·const·string·buttonIdentifier_assignedControllerSelection·=·"AssignedControllerSelection";4320 »       »       private·const·string·buttonIdentifier_assignedControllerSelection·=·"AssignedControllerSelection";
4321 4321
4322 »       »       private·const·string·buttonIdentifier_done·=·"Done";4322 »       »       private·const·string·buttonIdentifier_done·=·"Done";
4323 4323
4324 »       »       private·const·string·buttonIdentifier_restoreDefaults·=·"RestoreDefaults";4324 »       »       private·const·string·buttonIdentifier_restoreDefaults·=·"RestoreDefaults";
4325 4325
4326 »       »       [Tooltip("Must·be·assigned·a·Rewired·Input·Manager·scene·object·or·prefab.")] 
4327 »       »       [SerializeField]4326 »       »       [SerializeField]
 4327 »       »       [Tooltip("Must·be·assigned·a·Rewired·Input·Manager·scene·object·or·prefab.")]
4328 »       »       private·InputManager·_rewiredInputManager;4328 »       »       private·InputManager·_rewiredInputManager;
4329 4329
4330 »       »       [SerializeField] 
4331 »       »       [Tooltip("Set·to·True·to·prevent·the·Game·Object·from·being·destroyed·when·a·new·scene·is·loaded.\n\nNOTE:·Changing·this·value·from·True·to·False·at·runtime·will·have·no·effect·because·Object.DontDestroyOnLoad·cannot·be·undone·once·set.")]4330 »       »       [Tooltip("Set·to·True·to·prevent·the·Game·Object·from·being·destroyed·when·a·new·scene·is·loaded.\n\nNOTE:·Changing·this·value·from·True·to·False·at·runtime·will·have·no·effect·because·Object.DontDestroyOnLoad·cannot·be·undone·once·set.")]
 4331 »       »       [SerializeField]
4332 »       »       private·bool·_dontDestroyOnLoad;4332 »       »       private·bool·_dontDestroyOnLoad;
4333 4333
4334 »       »       [SerializeField]4334 »       »       [SerializeField]
4335 »       »       [Tooltip("Open·the·control·mapping·screen·immediately·on·start.·Mainly·used·for·testing.")]4335 »       »       [Tooltip("Open·the·control·mapping·screen·immediately·on·start.·Mainly·used·for·testing.")]
4336 »       »       private·bool·_openOnStart;4336 »       »       private·bool·_openOnStart;
4337 4337
4338 »       »       [SerializeField]4338 »       »       [SerializeField]
4339 »       »       [Tooltip("The·Layout·of·the·Keyboard·Maps·to·be·displayed.")]4339 »       »       [Tooltip("The·Layout·of·the·Keyboard·Maps·to·be·displayed.")]
4340 »       »       private·int·_keyboardMapDefaultLayout;4340 »       »       private·int·_keyboardMapDefaultLayout;
4341 4341
4342 »       »       [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")]4342 »       »       [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")]
4343 »       »       [SerializeField]4343 »       »       [SerializeField]
4344 »       »       private·int·_mouseMapDefaultLayout;4344 »       »       private·int·_mouseMapDefaultLayout;
4345 4345
4346 »       »       [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")] 
4347 »       »       [SerializeField]4346 »       »       [SerializeField]
 4347 »       »       [Tooltip("The·Layout·of·the·Mouse·Maps·to·be·displayed.")]
4348 »       »       private·int·_joystickMapDefaultLayout;4348 »       »       private·int·_joystickMapDefaultLayout;
4349 4349
4350 »       »       [SerializeField]4350 »       »       [SerializeField]
4351 »       »       private·ControlMapper.MappingSet[]·_mappingSets·=·new·ControlMapper.MappingSet[]·{·ControlMapper.MappingSet.Default·};4351 »       »       private·ControlMapper.MappingSet[]·_mappingSets·=·new·ControlMapper.MappingSet[]·{·ControlMapper.MappingSet.Default·};
4352 4352
4353 »       »       [Tooltip("Display·a·selectable·list·of·Players.·If·your·game·only·supports·1·player,·you·can·disable·this.")]4353 »       »       [Tooltip("Display·a·selectable·list·of·Players.·If·your·game·only·supports·1·player,·you·can·disable·this.")]
4354 »       »       [SerializeField]4354 »       »       [SerializeField]
4355 »       »       private·bool·_showPlayers·=·true;4355 »       »       private·bool·_showPlayers·=·true;
4356 4356
4357 »       »       [SerializeField] 
4358 »       »       [Tooltip("Display·the·Controller·column·for·input·mapping.")]4357 »       »       [Tooltip("Display·the·Controller·column·for·input·mapping.")]
 4358 »       »       [SerializeField]
4359 »       »       private·bool·_showControllers·=·true;4359 »       »       private·bool·_showControllers·=·true;
4360 4360
4361 »       »       [SerializeField] 
4362 »       »       [Tooltip("Display·the·Keyboard·column·for·input·mapping.")]4361 »       »       [Tooltip("Display·the·Keyboard·column·for·input·mapping.")]
 4362 »       »       [SerializeField]
4363 »       »       private·bool·_showKeyboard·=·true;4363 »       »       private·bool·_showKeyboard·=·true;
4364 4364
4365 »       »       [SerializeField]4365 »       »       [SerializeField]
4366 »       »       [Tooltip("Display·the·Mouse·column·for·input·mapping.")]4366 »       »       [Tooltip("Display·the·Mouse·column·for·input·mapping.")]
4367 »       »       private·bool·_showMouse·=·true;4367 »       »       private·bool·_showMouse·=·true;
4368 4368
4369 »       »       [SerializeField]4369 »       »       [SerializeField]
4370 »       »       [Tooltip("The·maximum·number·of·controllers·allowed·to·be·assigned·to·a·Player.·If·set·to·any·value·other·than·1,·a·selectable·list·of·currently-assigned·controller·will·be·displayed·to·the·user.·[0·=·infinite]")]4370 »       »       [Tooltip("The·maximum·number·of·controllers·allowed·to·be·assigned·to·a·Player.·If·set·to·any·value·other·than·1,·a·selectable·list·of·currently-assigned·controller·will·be·displayed·to·the·user.·[0·=·infinite]")]
4371 »       »       private·int·_maxControllersPerPlayer·=·1;4371 »       »       private·int·_maxControllersPerPlayer·=·1;
4372 4372
4373 »       »       [Tooltip("Display·section·labels·for·each·Action·Category·in·the·input·field·grid.·Only·applies·if·Action·Categories·are·used·to·display·the·Action·list.")]4373 »       »       [Tooltip("Display·section·labels·for·each·Action·Category·in·the·input·field·grid.·Only·applies·if·Action·Categories·are·used·to·display·the·Action·list.")]
4374 »       »       [SerializeField]4374 »       »       [SerializeField]
4375 »       »       private·bool·_showActionCategoryLabels;4375 »       »       private·bool·_showActionCategoryLabels;
4376 4376
4377 »       »       [SerializeField] 
4378 »       »       [Tooltip("The·number·of·input·fields·to·display·for·the·keyboard.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")]4377 »       »       [Tooltip("The·number·of·input·fields·to·display·for·the·keyboard.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")]
 4378 »       »       [SerializeField]
4379 »       »       private·int·_keyboardInputFieldCount·=·2;4379 »       »       private·int·_keyboardInputFieldCount·=·2;
4380 4380
4381 »       »       [Tooltip("The·number·of·input·fields·to·display·for·the·mouse.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")] 
4382 »       »       [SerializeField]4381 »       »       [SerializeField]
 4382 »       »       [Tooltip("The·number·of·input·fields·to·display·for·the·mouse.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")]
4383 »       »       private·int·_mouseInputFieldCount·=·1;4383 »       »       private·int·_mouseInputFieldCount·=·1;
4384 4384
4385 »       »       [Tooltip("The·number·of·input·fields·to·display·for·joysticks.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")]4385 »       »       [Tooltip("The·number·of·input·fields·to·display·for·joysticks.·If·you·want·to·support·alternate·mappings·on·the·same·device,·set·this·to·2·or·more.")]
4386 »       »       [SerializeField]4386 »       »       [SerializeField]
4387 »       »       private·int·_controllerInputFieldCount·=·1;4387 »       »       private·int·_controllerInputFieldCount·=·1;
4388 4388
4389 »       »       [Tooltip("Display·a·full-axis·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.·Also·displays·an·invert·toggle·for·the·user··to·invert·the·full-axis·assignment·direction.\n\n*IMPORTANT*:·This·field·is·required·if·you·have·made·any·full-axis·assignments·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data.·Disabling·this·field·when·you·have·full-axis·assignments·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·full-axis·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·axes·to·Actions.")]4389 »       »       [Tooltip("Display·a·full-axis·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.·Also·displays·an·invert·toggle·for·the·user··to·invert·the·full-axis·assignment·direction.\n\n*IMPORTANT*:·This·field·is·required·if·you·have·made·any·full-axis·assignments·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data.·Disabling·this·field·when·you·have·full-axis·assignments·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·full-axis·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·axes·to·Actions.")]
4390 »       »       [SerializeField]4390 »       »       [SerializeField]
4391 »       »       private·bool·_showFullAxisInputFields·=·true;4391 »       »       private·bool·_showFullAxisInputFields·=·true;
4392 4392
4393 »       »       [Tooltip("Display·a·positive·and·negative·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.\n\n*IMPORTANT*:·These·fields·are·required·to·assign·buttons,·keyboard·keys,·and·hat·or·D-Pad·directions·to·axis-type·Actions.·If·you·have·made·any·split-axis·assignments·or·button/key/D-pad·assignments·to·axis-type·Actions·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data,·disabling·these·fields·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·elements·to·Actions.")] 
4394 »       »       [SerializeField]4393 »       »       [SerializeField]
 4394 »       »       [Tooltip("Display·a·positive·and·negative·input·assignment·field·for·every·axis-type·Action·in·the·input·field·grid.\n\n*IMPORTANT*:·These·fields·are·required·to·assign·buttons,·keyboard·keys,·and·hat·or·D-Pad·directions·to·axis-type·Actions.·If·you·have·made·any·split-axis·assignments·or·button/key/D-pad·assignments·to·axis-type·Actions·in·the·Rewired·Input·Manager·or·in·saved·XML·user·data,·disabling·these·fields·will·result·in·the·inability·for·the·user·to·view,·remove,·or·modify·these·assignments.·In·addition,·these·assignments·may·cause·conflicts·when·trying·to·remap·the·same·elements·to·Actions.")]
4395 »       »       private·bool·_showSplitAxisInputFields·=·true;4395 »       »       private·bool·_showSplitAxisInputFields·=·true;
4396 4396
4397 »       »       [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·make·the·conflicting·assignment·anyway.")] 
4398 »       »       [SerializeField]4397 »       »       [SerializeField]
 4398 »       »       [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·make·the·conflicting·assignment·anyway.")]
4399 »       »       private·bool·_allowElementAssignmentConflicts;4399 »       »       private·bool·_allowElementAssignmentConflicts;
4400 4400
4401 »       »       [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·swap·conflicting·assignments.·This·only·applies·to·the·first·conflicting·assignment·found.·This·option·will·not·be·displayed·if·allowElementAssignmentConflicts·is·true.")]4401 »       »       [Tooltip("If·enabled,·when·an·element·assignment·conflict·is·found,·an·option·will·be·displayed·that·allows·the·user·to·swap·conflicting·assignments.·This·only·applies·to·the·first·conflicting·assignment·found.·This·option·will·not·be·displayed·if·allowElementAssignmentConflicts·is·true.")]
4402 »       »       [SerializeField]4402 »       »       [SerializeField]
4403 »       »       private·bool·_allowElementAssignmentSwap;4403 »       »       private·bool·_allowElementAssignmentSwap;
4404 4404
4405 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Action·label·column.")] 
4406 »       »       [SerializeField]4405 »       »       [SerializeField]
 4406 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Action·label·column.")]
4407 »       »       private·int·_actionLabelWidth·=·200;4407 »       »       private·int·_actionLabelWidth·=·200;
4408 4408
4409 »       »       [SerializeField]4409 »       »       [SerializeField]
4410 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Keyboard·column.")]4410 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Keyboard·column.")]
4411 »       »       private·int·_keyboardColMaxWidth·=·360;4411 »       »       private·int·_keyboardColMaxWidth·=·360;
4412 4412
4413 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Mouse·column.")]4413 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Mouse·column.")]
Offset 4418, 16 lines modifiedOffset 4418, 16 lines modified
4418 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Controller·column.")]4418 »       »       [Tooltip("The·width·in·relative·pixels·of·the·Controller·column.")]
4419 »       »       private·int·_controllerColMaxWidth·=·200;4419 »       »       private·int·_controllerColMaxWidth·=·200;
4420 4420
4421 »       »       [SerializeField]4421 »       »       [SerializeField]
4422 »       »       [Tooltip("The·height·in·relative·pixels·of·the·input·grid·button·rows.")]4422 »       »       [Tooltip("The·height·in·relative·pixels·of·the·input·grid·button·rows.")]
4423 »       »       private·int·_inputRowHeight·=·40;4423 »       »       private·int·_inputRowHeight·=·40;
4424 4424
4425 »       »       [Tooltip("The·padding·of·the·input·grid·button·rows.")] 
4426 »       »       [SerializeField]4425 »       »       [SerializeField]
 4426 »       »       [Tooltip("The·padding·of·the·input·grid·button·rows.")]
4427 »       »       private·RectOffset·_inputRowPadding·=·new·RectOffset();4427 »       »       private·RectOffset·_inputRowPadding·=·new·RectOffset();
4428 4428
4429 »       »       [SerializeField]4429 »       »       [SerializeField]
4430 »       »       [Tooltip("The·width·in·relative·pixels·of·spacing·between·input·fields·in·a·single·column.")]4430 »       »       [Tooltip("The·width·in·relative·pixels·of·spacing·between·input·fields·in·a·single·column.")]
4431 »       »       private·int·_inputRowFieldSpacing;4431 »       »       private·int·_inputRowFieldSpacing;
4432 4432
4433 »       »       [SerializeField]4433 »       »       [SerializeField]
Offset 4442, 20 lines modifiedOffset 4442, 20 lines modified
4442 »       »       [Tooltip("The·width·in·relative·pixels·of·the·invert·toggle·buttons.")]4442 »       »       [Tooltip("The·width·in·relative·pixels·of·the·invert·toggle·buttons.")]
4443 »       »       private·int·_invertToggleWidth·=·40;4443 »       »       private·int·_invertToggleWidth·=·40;
4444 4444
Max diff block lines reached; 8797/16356 bytes (53.78%) of diff not shown.
4.35 KB
Assembly-CSharp/Rewired/UI/ControlMapper/LanguageData.cs
Ordering differences only
    
Offset 661, 39 lines modifiedOffset 661, 39 lines modified
661 661
662 »       »       [SerializeField]662 »       »       [SerializeField]
663 »       »       private·string·_assignControllerWindowMessage·=·"Press·any·button·or·move·an·axis·on·the·controller·you·would·like·to·use.";663 »       »       private·string·_assignControllerWindowMessage·=·"Press·any·button·or·move·an·axis·on·the·controller·you·would·like·to·use.";
664 664
665 »       »       [SerializeField]665 »       »       [SerializeField]
666 »       »       private·string·_controllerAssignmentConflictWindowTitle·=·"Controller·Assignment";666 »       »       private·string·_controllerAssignmentConflictWindowTitle·=·"Controller·Assignment";
667 667
668 »       »       [SerializeField] 
669 »       »       [Tooltip("{0}·=·Joystick·Name\n{1}·=·Other·Player·Name\n{2}·=·This·Player·Name")]668 »       »       [Tooltip("{0}·=·Joystick·Name\n{1}·=·Other·Player·Name\n{2}·=·This·Player·Name")]
 669 »       »       [SerializeField]
670 »       »       private·string·_controllerAssignmentConflictWindowMessage·=·"{0}·is·already·assigned·to·{1}.·Do·you·want·to·assign·this·controller·to·{2}·instead?";670 »       »       private·string·_controllerAssignmentConflictWindowMessage·=·"{0}·is·already·assigned·to·{1}.·Do·you·want·to·assign·this·controller·to·{2}·instead?";
671 671
672 »       »       [SerializeField]672 »       »       [SerializeField]
673 »       »       private·string·_elementAssignmentPrePollingWindowMessage·=·"First·center·or·zero·all·sticks·and·axes·and·press·any·button·or·wait·for·the·timer·to·finish.";673 »       »       private·string·_elementAssignmentPrePollingWindowMessage·=·"First·center·or·zero·all·sticks·and·axes·and·press·any·button·or·wait·for·the·timer·to·finish.";
674 674
675 »       »       [Tooltip("{0}·=·Action·Name")] 
676 »       »       [SerializeField]675 »       »       [SerializeField]
 676 »       »       [Tooltip("{0}·=·Action·Name")]
677 »       »       private·string·_joystickElementAssignmentPollingWindowMessage·=·"Now·press·a·button·or·move·an·axis·to·assign·it·to·{0}.";677 »       »       private·string·_joystickElementAssignmentPollingWindowMessage·=·"Now·press·a·button·or·move·an·axis·to·assign·it·to·{0}.";
678 678
679 »       »       [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")] 
680 »       »       [SerializeField]679 »       »       [SerializeField]
 680 »       »       [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")]
681 »       »       private·string·_joystickElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Now·move·an·axis·to·assign·it·to·{0}.";681 »       »       private·string·_joystickElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Now·move·an·axis·to·assign·it·to·{0}.";
682 682
683 »       »       [SerializeField]683 »       »       [SerializeField]
684 »       »       [Tooltip("{0}·=·Action·Name")]684 »       »       [Tooltip("{0}·=·Action·Name")]
685 »       »       private·string·_keyboardElementAssignmentPollingWindowMessage·=·"Press·a·key·to·assign·it·to·{0}.·Modifier·keys·may·also·be·used.·To·assign·a·modifier·key·alone,·hold·it·down·for·1·second.";685 »       »       private·string·_keyboardElementAssignmentPollingWindowMessage·=·"Press·a·key·to·assign·it·to·{0}.·Modifier·keys·may·also·be·used.·To·assign·a·modifier·key·alone,·hold·it·down·for·1·second.";
686 686
687 »       »       [SerializeField]687 »       »       [SerializeField]
688 »       »       [Tooltip("{0}·=·Action·Name")]688 »       »       [Tooltip("{0}·=·Action·Name")]
689 »       »       private·string·_mouseElementAssignmentPollingWindowMessage·=·"Press·a·mouse·button·or·move·an·axis·to·assign·it·to·{0}.";689 »       »       private·string·_mouseElementAssignmentPollingWindowMessage·=·"Press·a·mouse·button·or·move·an·axis·to·assign·it·to·{0}.";
690 690
691 »       »       [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")] 
692 »       »       [SerializeField]691 »       »       [SerializeField]
 692 »       »       [Tooltip("This·text·is·only·displayed·when·split-axis·fields·have·been·disabled·and·the·user·clicks·on·the·full-axis·field.·Button/key/D-pad·input·cannot·be·assigned·to·a·full-axis·field.\n{0}·=·Action·Name")]
693 »       »       private·string·_mouseElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Move·an·axis·to·assign·it·to·{0}.";693 »       »       private·string·_mouseElementAssignmentPollingWindowMessage_fullAxisFieldOnly·=·"Move·an·axis·to·assign·it·to·{0}.";
694 694
695 »       »       [SerializeField]695 »       »       [SerializeField]
696 »       »       private·string·_elementAssignmentConflictWindowMessage·=·"Assignment·Conflict";696 »       »       private·string·_elementAssignmentConflictWindowMessage·=·"Assignment·Conflict";
697 697
698 »       »       [SerializeField]698 »       »       [SerializeField]
699 »       »       [Tooltip("{0}·=·Element·Name")]699 »       »       [Tooltip("{0}·=·Element·Name")]
Offset 706, 16 lines modifiedOffset 706, 16 lines modified
706 »       »       [SerializeField]706 »       »       [SerializeField]
707 »       »       [Tooltip("{0}·=·Element·Name")]707 »       »       [Tooltip("{0}·=·Element·Name")]
708 »       »       private·string·_elementAlreadyInUseCanReplace_conflictAllowed·=·"{0}·is·already·in·use.·Do·you·want·to·replace·it?·You·may·also·choose·to·add·the·assignment·anyway.";708 »       »       private·string·_elementAlreadyInUseCanReplace_conflictAllowed·=·"{0}·is·already·in·use.·Do·you·want·to·replace·it?·You·may·also·choose·to·add·the·assignment·anyway.";
709 709
710 »       »       [SerializeField]710 »       »       [SerializeField]
711 »       »       private·string·_mouseAssignmentConflictWindowTitle·=·"Mouse·Assignment";711 »       »       private·string·_mouseAssignmentConflictWindowTitle·=·"Mouse·Assignment";
712 712
713 »       »       [SerializeField] 
714 »       »       [Tooltip("{0}·=·Other·Player·Name\n{1}·=·This·Player·Name")]713 »       »       [Tooltip("{0}·=·Other·Player·Name\n{1}·=·This·Player·Name")]
 714 »       »       [SerializeField]
715 »       »       private·string·_mouseAssignmentConflictWindowMessage·=·"The·mouse·is·already·assigned·to·{0}.·Do·you·want·to·assign·the·mouse·to·{1}·instead?";715 »       »       private·string·_mouseAssignmentConflictWindowMessage·=·"The·mouse·is·already·assigned·to·{0}.·Do·you·want·to·assign·the·mouse·to·{1}·instead?";
716 716
717 »       »       [SerializeField]717 »       »       [SerializeField]
718 »       »       private·string·_calibrateControllerWindowTitle·=·"Calibrate·Controller";718 »       »       private·string·_calibrateControllerWindowTitle·=·"Calibrate·Controller";
719 719
720 »       »       [SerializeField]720 »       »       [SerializeField]
721 »       »       private·string·_calibrateAxisStep1WindowTitle·=·"Calibrate·Zero";721 »       »       private·string·_calibrateAxisStep1WindowTitle·=·"Calibrate·Zero";
Offset 737, 16 lines modifiedOffset 737, 16 lines modified
737 »       »       [SerializeField]737 »       »       [SerializeField]
738 »       »       private·string·_restoreDefaultsWindowTitle·=·"Restore·Defaults";738 »       »       private·string·_restoreDefaultsWindowTitle·=·"Restore·Defaults";
739 739
740 »       »       [Tooltip("Message·for·a·single·player·game.")]740 »       »       [Tooltip("Message·for·a·single·player·game.")]
741 »       »       [SerializeField]741 »       »       [SerializeField]
742 »       »       private·string·_restoreDefaultsWindowMessage_onePlayer·=·"This·will·restore·the·default·input·configuration.·Are·you·sure·you·want·to·do·this?";742 »       »       private·string·_restoreDefaultsWindowMessage_onePlayer·=·"This·will·restore·the·default·input·configuration.·Are·you·sure·you·want·to·do·this?";
743 743
744 »       »       [Tooltip("Message·for·a·multi-player·game.")] 
745 »       »       [SerializeField]744 »       »       [SerializeField]
 745 »       »       [Tooltip("Message·for·a·multi-player·game.")]
746 »       »       private·string·_restoreDefaultsWindowMessage_multiPlayer·=·"This·will·restore·the·default·input·configuration·for·all·players.·Are·you·sure·you·want·to·do·this?";746 »       »       private·string·_restoreDefaultsWindowMessage_multiPlayer·=·"This·will·restore·the·default·input·configuration·for·all·players.·Are·you·sure·you·want·to·do·this?";
747 747
748 »       »       [SerializeField]748 »       »       [SerializeField]
749 »       »       private·string·_actionColumnLabel·=·"Actions";749 »       »       private·string·_actionColumnLabel·=·"Actions";
750 750
751 »       »       [SerializeField]751 »       »       [SerializeField]
752 »       »       private·string·_keyboardColumnLabel·=·"Keyboard";752 »       »       private·string·_keyboardColumnLabel·=·"Keyboard";
646 B
Assembly-CSharp/Rewired/UI/ControlMapper/ScrollRectSelectableChild.cs
Ordering differences only
    
Offset 2, 16 lines modifiedOffset 2, 16 lines modified
2 using·Rewired.Utils;2 using·Rewired.Utils;
3 using·UnityEngine;3 using·UnityEngine;
4 using·UnityEngine.EventSystems;4 using·UnityEngine.EventSystems;
5 using·UnityEngine.UI;5 using·UnityEngine.UI;
6 6
7 namespace·Rewired.UI.ControlMapper7 namespace·Rewired.UI.ControlMapper
8 {8 {
9 »       [AddComponentMenu("")] 
10 »       [RequireComponent(typeof(Selectable))]9 »       [RequireComponent(typeof(Selectable))]
 10 »       [AddComponentMenu("")]
11 »       public·class·ScrollRectSelectableChild·:·MonoBehaviour,·ISelectHandler,·IEventSystemHandler11 »       public·class·ScrollRectSelectableChild·:·MonoBehaviour,·ISelectHandler,·IEventSystemHandler
12 »       {12 »       {
13 »       »       private·RectTransform·parentScrollRectContentTransform13 »       »       private·RectTransform·parentScrollRectContentTransform
14 »       »       {14 »       »       {
15 »       »       »       get15 »       »       »       get
16 »       »       »       {16 »       »       »       {
17 »       »       »       »       return·this.parentScrollRect.content;17 »       »       »       »       return·this.parentScrollRect.content;
612 B
Assembly-CSharp/Rewired/UI/ControlMapper/UIImageHelper.cs
Ordering differences only
    
Offset 1, 15 lines modifiedOffset 1, 15 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 using·UnityEngine.UI;3 using·UnityEngine.UI;
4 4
5 namespace·Rewired.UI.ControlMapper5 namespace·Rewired.UI.ControlMapper
6 {6 {
7 »       [RequireComponent(typeof(Image))] 
8 »       [AddComponentMenu("")]7 »       [AddComponentMenu("")]
 8 »       [RequireComponent(typeof(Image))]
9 »       public·class·UIImageHelper·:·MonoBehaviour9 »       public·class·UIImageHelper·:·MonoBehaviour
10 »       {10 »       {
11 »       »       public·void·SetEnabledState(bool·newState)11 »       »       public·void·SetEnabledState(bool·newState)
12 »       »       {12 »       »       {
13 »       »       »       this.currentState·=·newState;13 »       »       »       this.currentState·=·newState;
14 »       »       »       UIImageHelper.State·state·=·(newState·?·this.enabledState·:·this.disabledState);14 »       »       »       UIImageHelper.State·state·=·(newState·?·this.enabledState·:·this.disabledState);
15 »       »       »       if·(state·==·null)15 »       »       »       if·(state·==·null)
2.94 KB
Assembly-CSharp/RewiredConsts/Action.cs
    
Offset 142, 43 lines modifiedOffset 142, 40 lines modified
142 142
143 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuLB")]143 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuLB")]
144 »       »       public·const·int·MenuLB·=·52;144 »       »       public·const·int·MenuLB·=·52;
145 145
146 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuRB")]146 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"MenuRB")]
147 »       »       public·const·int·MenuRB·=·53;147 »       »       public·const·int·MenuRB·=·53;
148 148
149 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolRB")]149 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Next·Page")]
150 »       »       public·const·int·DebugToolRB·=·56;150 »       »       public·const·int·DebugPageNext·=·56;
151 151
152 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolLB")]152 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Previous·Page")]
153 »       »       public·const·int·DebugToolLB·=·57;153 »       »       public·const·int·DebugPagePrev·=·57;
154 154
155 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolRT")]155 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Next·Subpage")]
156 »       »       public·const·int·DebugToolRT·=·58;156 »       »       public·const·int·DebugSubpageNext·=·58;
157 157
158 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolLT")]158 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"Debug·Previous·Subpage")]
159 »       »       public·const·int·DebugToolLT·=·59;159 »       »       public·const·int·DebugSubpagePrev·=·59;
160 160
161 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolStart")] 
162 »       »       public·const·int·DebugToolStart·=·60; 
163  
164 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolNavLeft")]161 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugNavVertical")]
165 »       »       public·const·int·DebugToolNavLeft·=·61;162 »       »       public·const·int·DebugNavVertical·=·63;
166 163
167 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolNavRight")]164 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugNavHorizontal")]
168 »       »       public·const·int·DebugToolNavRight·=·62;165 »       »       public·const·int·DebugNavHorizontal·=·75;
169 166
170 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolVertical")]167 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugConfirm")]
171 »       »       public·const·int·DebugToolVertical·=·63;168 »       »       public·const·int·DebugConfirm·=·65;
172 169
173 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolConfirm")]170 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugCancel")]
174 »       »       public·const·int·DebugToolConfirm·=·65;171 »       »       public·const·int·DebugCancel·=·66;
175 172
176 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolCancel")]173 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolStart")]
177 »       »       public·const·int·DebugToolCancel·=·66;174 »       »       public·const·int·DebugToolStart·=·60;
178 175
179 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolCopy")]176 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolCopy")]
180 »       »       public·const·int·DebugToolCopy·=·67;177 »       »       public·const·int·DebugToolCopy·=·67;
181 178
182 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolClear")]179 »       »       [ActionIdFieldInfo(categoryName·=·"Default",·friendlyName·=·"DebugToolClear")]
183 »       »       public·const·int·DebugToolClear·=·68;180 »       »       public·const·int·DebugToolClear·=·68;
184 181
312 B
Assembly-CSharp/RewiredConsts/Category.cs
    
Offset 12, 10 lines modifiedOffset 12, 10 lines modified
12 12
13 »       »       public·const·int·Task·=·3;13 »       »       public·const·int·Task·=·3;
14 14
15 »       »       public·const·int·QuickChat·=·4;15 »       »       public·const·int·QuickChat·=·4;
16 16
17 »       »       public·const·int·Protected_Keyboard_Controls·=·5;17 »       »       public·const·int·Protected_Keyboard_Controls·=·5;
18 18
19 »       »       public·const·int·DebugTool·=·6;19 »       »       public·const·int·Debug·=·6;
20 »       }20 »       }
21 }21 }
811 B
Assembly-CSharp/RewiredConstsEnum.cs
    
Offset 43, 10 lines modifiedOffset 43, 36 lines modified
43 »       »       ActionQuaternary·=·49,43 »       »       ActionQuaternary·=·49,
44 »       »       UseVent,44 »       »       UseVent,
45 »       »       MenuLB·=·52,45 »       »       MenuLB·=·52,
46 »       »       MenuRB,46 »       »       MenuRB,
47 »       »       QuickChatFavorite·=·69,47 »       »       QuickChatFavorite·=·69,
48 »       »       QuickChatClear,48 »       »       QuickChatClear,
49 »       »       ChatSend,49 »       »       ChatSend,
50 »       »       QuickChatOpen50 »       »       QuickChatOpen,
 51 »       »       DebugPageNext·=·56,
 52 »       »       DebugPagePrev,
 53 »       »       DebugSubpageNext,
 54 »       »       DebugSubpagePrev,
 55 »       »       DebugNavVertical·=·63,
 56 »       »       DebugNavHorizontal·=·75,
 57 »       »       DebugConfirm·=·65,
 58 »       »       DebugCancel,
 59 »       »       DebugToolStart·=·60,
 60 »       »       DebugToolCopy·=·67,
 61 »       »       DebugToolClear
 62 »       }
 63
 64 »       public·enum·DebugAction
 65 »       {
 66 »       »       DebugPageNext·=·56,
 67 »       »       DebugPagePrev,
 68 »       »       DebugSubpageNext,
 69 »       »       DebugSubpagePrev,
 70 »       »       DebugNavVertical·=·63,
 71 »       »       DebugNavHorizontal·=·75,
 72 »       »       DebugConfirm·=·65,
 73 »       »       DebugCancel,
 74 »       »       DebugToolStart·=·60,
 75 »       »       DebugToolCopy·=·67,
 76 »       »       DebugToolClear
51 »       }77 »       }
52 }78 }
781 B
Assembly-CSharp/RoastMarshmallowFireMinigame.cs
Ordering differences only
    
Offset 254, 29 lines modifiedOffset 254, 29 lines modified
254 »       [Range(0.1f,·10f)]254 »       [Range(0.1f,·10f)]
255 »       private·float·timeToToasted·=·5f;255 »       private·float·timeToToasted·=·5f;
256 256
257 »       [SerializeField]257 »       [SerializeField]
258 »       [Range(0.1f,·10f)]258 »       [Range(0.1f,·10f)]
259 »       private·float·timeToBurnt·=·3f;259 »       private·float·timeToBurnt·=·3f;
260 260
261 »       [SerializeField] 
262 »       [Header("Animators")]261 »       [Header("Animators")]
 262 »       [SerializeField]
263 »       private·Animator·fireAnimator;263 »       private·Animator·fireAnimator;
264 264
265 »       [SerializeField]265 »       [SerializeField]
266 »       private·Animator·bagAnimator;266 »       private·Animator·bagAnimator;
267 267
268 »       [SerializeField]268 »       [SerializeField]
269 »       private·Animator·stickAnimator;269 »       private·Animator·stickAnimator;
270 270
271 »       [SerializeField]271 »       [SerializeField]
272 »       private·Animator·marshmallowAnimator;272 »       private·Animator·marshmallowAnimator;
273 273
274 »       [SerializeField] 
275 »       [Space(10f)]274 »       [Space(10f)]
 275 »       [SerializeField]
276 »       private·SpriteRenderer·toastedMarshmallow;276 »       private·SpriteRenderer·toastedMarshmallow;
277 277
278 »       [SerializeField]278 »       [SerializeField]
279 »       [Header("Buttons")]279 »       [Header("Buttons")]
280 »       private·PassiveButton·bagMarshmallowButton;280 »       private·PassiveButton·bagMarshmallowButton;
281 281
282 »       [SerializeField]282 »       [SerializeField]
3.51 KB
Assembly-CSharp/RoleBehaviour.cs
    
Offset 107, 25 lines modifiedOffset 107, 44 lines modified
107 »       {107 »       {
108 »       }108 »       }
109 109
110 »       public·virtual·void·UseAbility()110 »       public·virtual·void·UseAbility()
111 »       {111 »       {
112 »       }112 »       }
113 113
 114 »       public·virtual·void·OnMeetingStart()
 115 »       {
 116 »       }
 117
114 »       public·virtual·void·OnVotingComplete()118 »       public·virtual·void·OnVotingComplete()
115 »       {119 »       {
116 »       }120 »       }
117 121
 122 »       public·virtual·void·OnDeath(DeathReason·reason)
 123 »       {
 124 »       }
 125
118 »       public·virtual·void·Initialize(PlayerControl·player)126 »       public·virtual·void·Initialize(PlayerControl·player)
119 »       {127 »       {
120 »       »       this.Player·=·player;128 »       »       this.Player·=·player;
121 »       »       if·(!player.AmOwner)129 »       »       if·(!player.AmOwner)
122 »       »       {130 »       »       {
123 »       »       »       return;131 »       »       »       return;
124 »       »       }132 »       »       }
 133 »       »       if·(this.IsImpostor)
 134 »       »       {
 135 »       »       »       if·(this.CanUseKillButton)
 136 »       »       »       {
 137 »       »       »       »       DestroyableSingleton<HudManager>.Instance.KillButton.Show();
 138 »       »       »       »       player.SetKillTimer(10f);
 139 »       »       »       }
 140 »       »       »       DestroyableSingleton<HudManager>.Instance.SabotageButton.Show();
 141 »       »       »       DestroyableSingleton<HudManager>.Instance.AdminButton.Show();
 142 »       »       »       DestroyableSingleton<HudManager>.Instance.ImpostorVentButton.Show();
 143 »       »       }
125 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(player,·this,·true);144 »       »       DestroyableSingleton<HudManager>.Instance.SetHudActive(player,·this,·true);
126 »       »       PlayerNameColor.SetForRoleDirectly(player,·this);145 »       »       PlayerNameColor.SetForRoleDirectly(player,·this);
127 »       »       this.InitializeAbilityButton();146 »       »       this.InitializeAbilityButton();
128 »       }147 »       }
129 148
130 »       public·virtual·void·SetUsableTarget(IUsable·target)149 »       public·virtual·void·SetUsableTarget(IUsable·target)
131 »       {150 »       {
Offset 154, 17 lines modifiedOffset 173, 17 lines modified
154 »       }173 »       }
155 174
156 »       private·void·SetAbilityUsesRemaining(int·num)175 »       private·void·SetAbilityUsesRemaining(int·num)
157 »       {176 »       {
158 »       »       this.buttonManager.SetUsesRemaining(num);177 »       »       this.buttonManager.SetUsesRemaining(num);
159 »       }178 »       }
160 179
161 »       protected·virtual·bool·IsValidTarget(GameData.PlayerInfo·target)180 »       protected·virtual·bool·IsValidTarget(NetworkedPlayerInfo·target)
162 »       {181 »       {
163 »       »       return·target·!=·null·&&·!target.Disconnected·&&·!target.IsDead·&&·target.PlayerId·!=·this.Player.PlayerId·&&·!(target.Role·==·null)·&&·!(target.Object·==·null)·&&·!target.Object.inVent·&&·!target.Object.inMovingPlat;182 »       »       return·!(target·==·null)·&&·!target.Disconnected·&&·!target.IsDead·&&·target.PlayerId·!=·this.Player.PlayerId·&&·!(target.Role·==·null)·&&·!(target.Object·==·null)·&&·!target.Object.inVent·&&·!target.Object.inMovingPlat·&&·target.Object.Visible;
164 »       }183 »       }
165 184
166 »       public·virtual·PlayerControl·FindClosestTarget()185 »       public·virtual·PlayerControl·FindClosestTarget()
167 »       {186 »       {
168 »       »       return·null;187 »       »       return·null;
169 »       }188 »       }
170 189
Offset 184, 21 lines modifiedOffset 203, 21 lines modified
184 »       }203 »       }
185 204
186 »       protected·List<PlayerControl>·GetPlayersInAbilityRangeSorted(List<PlayerControl>·outputList,·bool·ignoreColliders)205 »       protected·List<PlayerControl>·GetPlayersInAbilityRangeSorted(List<PlayerControl>·outputList,·bool·ignoreColliders)
187 »       {206 »       {
188 »       »       outputList.Clear();207 »       »       outputList.Clear();
189 »       »       float·abilityDistance·=·this.GetAbilityDistance();208 »       »       float·abilityDistance·=·this.GetAbilityDistance();
190 »       »       Vector2·myPos·=·this.Player.GetTruePosition();209 »       »       Vector2·myPos·=·this.Player.GetTruePosition();
191 »       »       List<GameData.PlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers;210 »       »       List<NetworkedPlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers;
192 »       »       for·(int·i·=·0;·i·<·allPlayers.Count;·i++)211 »       »       for·(int·i·=·0;·i·<·allPlayers.Count;·i++)
193 »       »       {212 »       »       {
194 »       »       »       GameData.PlayerInfo·playerInfo·=·allPlayers[i];213 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·allPlayers[i];
195 »       »       »       if·(this.IsValidTarget(playerInfo))214 »       »       »       if·(this.IsValidTarget(networkedPlayerInfo))
196 »       »       »       {215 »       »       »       {
197 »       »       »       »       PlayerControl·@object·=·playerInfo.Object;216 »       »       »       »       PlayerControl·@object·=·networkedPlayerInfo.Object;
198 »       »       »       »       if·(@object·&&·@object.Collider.enabled)217 »       »       »       »       if·(@object·&&·@object.Collider.enabled)
199 »       »       »       »       {218 »       »       »       »       {
200 »       »       »       »       »       Vector2·vector·=·@object.GetTruePosition()·-·myPos;219 »       »       »       »       »       Vector2·vector·=·@object.GetTruePosition()·-·myPos;
201 »       »       »       »       »       float·magnitude·=·vector.magnitude;220 »       »       »       »       »       float·magnitude·=·vector.magnitude;
202 »       »       »       »       »       if·(magnitude·<=·abilityDistance·&&·(ignoreColliders·||·!PhysicsHelpers.AnyNonTriggersBetween(myPos,·vector.normalized,·magnitude,·Constants.ShipAndObjectsMask)))221 »       »       »       »       »       if·(magnitude·<=·abilityDistance·&&·(ignoreColliders·||·!PhysicsHelpers.AnyNonTriggersBetween(myPos,·vector.normalized,·magnitude,·Constants.ShipAndObjectsMask)))
203 »       »       »       »       »       {222 »       »       »       »       »       {
204 »       »       »       »       »       »       outputList.Add(@object);223 »       »       »       »       »       »       outputList.Add(@object);
Offset 238, 14 lines modifiedOffset 257, 20 lines modified
238 257
239 »       public·StringNames·BlurbName·=·StringNames.CrewmateBlurb;258 »       public·StringNames·BlurbName·=·StringNames.CrewmateBlurb;
240 259
241 »       public·StringNames·BlurbNameMed·=·StringNames.CrewmateBlurb;260 »       public·StringNames·BlurbNameMed·=·StringNames.CrewmateBlurb;
242 261
243 »       public·StringNames·BlurbNameLong·=·StringNames.CrewmateBlurb;262 »       public·StringNames·BlurbNameLong·=·StringNames.CrewmateBlurb;
244 263
 264 »       public·Sprite·RoleIconSolid;
 265
 266 »       public·Sprite·RoleIconWhite;
 267
 268 »       public·Sprite·RoleScreenshot;
 269
245 »       public·Color·NameColor·=·Color.white;270 »       public·Color·NameColor·=·Color.white;
246 271
247 »       public·bool·TasksCountTowardProgress·=·true;272 »       public·bool·TasksCountTowardProgress·=·true;
248 273
249 »       public·bool·CanUseKillButton;274 »       public·bool·CanUseKillButton;
250 275
251 »       public·bool·CanBeKilled·=·true;276 »       public·bool·CanBeKilled·=·true;
1.79 KB
Assembly-CSharp/RoleEffectAnimation.cs
    
Offset 1, 24 lines modifiedOffset 1, 32 lines modified
1 using·System;1 using·System;
2 using·System.Collections;2 using·System.Collections;
3 using·PowerTools;3 using·PowerTools;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·RoleEffectAnimation·:·MonoBehaviour6 public·class·RoleEffectAnimation·:·MonoBehaviour
7 {7 {
8 »       public·void·Play(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f)8 »       public·void·Play(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f,·bool·parentTransform·=·true,·float·flipXOffset·=·0f)
9 »       {9 »       {
10 »       »       base.StartCoroutine(this.CoPlay(parent,·onClipEnded,·flipX,·soundType,·duration));10 »       »       base.StartCoroutine(this.CoPlay(parent,·onClipEnded,·flipX,·soundType,·duration,·parentTransform,·flipXOffset));
11 »       }11 »       }
12 12
13 »       private·IEnumerator·CoPlay(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f)13 »       private·IEnumerator·CoPlay(PlayerControl·parent,·Action·onClipEnded,·bool·flipX,·RoleEffectAnimation.SoundType·soundType,·float·duration·=·0f,·bool·parentTransform·=·true,·float·flipXOffset·=·0f)
14 »       {14 »       {
15 »       »       this.parent·=·parent;15 »       »       this.parent·=·parent;
 16 »       »       if·(!parentTransform)
 17 »       »       {
 18 »       »       »       base.transform.parent·=·null;
 19 »       »       }
16 »       »       parent.currentRoleAnimations.Add(this);20 »       »       parent.currentRoleAnimations.Add(this);
17 »       »       this.Renderer.flipX·=·flipX;21 »       »       this.Renderer.flipX·=·flipX;
 22 »       »       if·(flipX)
 23 »       »       {
 24 »       »       »       base.transform.position·+=·new·Vector3(flipXOffset,·0f,·0f);
 25 »       »       }
18 »       »       if·(this.UseSound)26 »       »       if·(this.UseSound)
19 »       »       {27 »       »       {
20 »       »       »       if·(soundType·!=·RoleEffectAnimation.SoundType.Local)28 »       »       »       if·(soundType·!=·RoleEffectAnimation.SoundType.Local)
21 »       »       »       {29 »       »       »       {
22 »       »       »       »       if·(soundType·==·RoleEffectAnimation.SoundType.Global)30 »       »       »       »       if·(soundType·==·RoleEffectAnimation.SoundType.Global)
23 »       »       »       »       {31 »       »       »       »       {
24 »       »       »       »       »       SoundManager.Instance.PlaySound(this.UseSound,·false,·1f,·null);32 »       »       »       »       »       SoundManager.Instance.PlaySound(this.UseSound,·false,·1f,·null);
Offset 109, 10 lines modifiedOffset 117, 13 lines modified
109 »       »       Global117 »       »       Global
110 »       }118 »       }
111 119
112 »       public·enum·EffectType120 »       public·enum·EffectType
113 »       {121 »       {
114 »       »       Default,122 »       »       Default,
115 »       »       ProtectLoop,123 »       »       ProtectLoop,
116 »       »       Shapeshift124 »       »       Shapeshift,
 125 »       »       Vanish_Charge,
 126 »       »       Vanish_Poof,
 127 »       »       Appear_Poof
117 »       }128 »       }
118 }129 }
5.3 KB
Assembly-CSharp/RoleManager.cs
    
Offset 21, 26 lines modifiedOffset 21, 26 lines modified
21 21
22 »       public·void·SetRole(PlayerControl·targetPlayer,·RoleTypes·roleType)22 »       public·void·SetRole(PlayerControl·targetPlayer,·RoleTypes·roleType)
23 »       {23 »       {
24 »       »       if·(!targetPlayer)24 »       »       if·(!targetPlayer)
25 »       »       {25 »       »       {
26 »       »       »       return;26 »       »       »       return;
27 »       »       }27 »       »       }
28 »       »       GameData.PlayerInfo·data·=·targetPlayer.Data;28 »       »       NetworkedPlayerInfo·data·=·targetPlayer.Data;
29 »       »       if·(data·==·null)29 »       »       if·(data·==·null)
30 »       »       {30 »       »       {
31 »       »       »       Debug.LogError("It·shouldn't·be·possible,·but·"·+·targetPlayer.name·+·"·still·doesn't·have·PlayerData·during·role·selection.");31 »       »       »       Debug.LogError("It·shouldn't·be·possible,·but·"·+·targetPlayer.name·+·"·still·doesn't·have·PlayerData·during·role·selection.");
32 »       »       »       return;32 »       »       »       return;
33 »       »       }33 »       »       }
34 »       »       if·(data.Role)34 »       »       if·(data.Role)
35 »       »       {35 »       »       {
36 »       »       »       data.Role.Deinitialize(targetPlayer);36 »       »       »       data.Role.Deinitialize(targetPlayer);
37 »       »       »       Object.Destroy(data.Role.gameObject);37 »       »       »       Object.Destroy(data.Role.gameObject);
38 »       »       }38 »       »       }
39 »       »       RoleBehaviour·roleBehaviour·=·Object.Instantiate<RoleBehaviour>(Enumerable.First<RoleBehaviour>(this.AllRoles,·(RoleBehaviour·r)·=>·r.Role·==·roleType),·GameData.Instance.transform);39 »       »       RoleBehaviour·roleBehaviour·=·Object.Instantiate<RoleBehaviour>(Enumerable.First<RoleBehaviour>(this.AllRoles,·(RoleBehaviour·r)·=>·r.Role·==·roleType),·data.gameObject.transform);
40 »       »       roleBehaviour.Initialize(targetPlayer);40 »       »       roleBehaviour.Initialize(targetPlayer);
41 »       »       targetPlayer.Data.Role·=·roleBehaviour;41 »       »       targetPlayer.Data.Role·=·roleBehaviour;
42 »       »       targetPlayer.Data.RoleType·=·roleType;42 »       »       targetPlayer.Data.RoleType·=·roleType;
43 »       »       if·(roleType·!=·RoleTypes.ImpostorGhost·&&·roleType·!=·RoleTypes.CrewmateGhost)43 »       »       if·(roleType·!=·RoleTypes.ImpostorGhost·&&·roleType·!=·RoleTypes.CrewmateGhost)
44 »       »       {44 »       »       {
45 »       »       »       targetPlayer.Data.RoleWhenAlive·=·new·RoleTypes?(roleType);45 »       »       »       targetPlayer.Data.RoleWhenAlive·=·new·RoleTypes?(roleType);
46 »       »       }46 »       »       }
Offset 56, 20 lines modifiedOffset 56, 20 lines modified
56 »       »       }56 »       »       }
57 »       }57 »       }
58 58
59 »       public·void·SelectRoles()59 »       public·void·SelectRoles()
60 »       {60 »       {
61 »       »       List<ClientData>·list·=·new·List<ClientData>();61 »       »       List<ClientData>·list·=·new·List<ClientData>();
62 »       »       AmongUsClient.Instance.GetAllClients(list);62 »       »       AmongUsClient.Instance.GetAllClients(list);
63 »       »       List<GameData.PlayerInfo>·list2·=·Enumerable.ToList<GameData.PlayerInfo>(Enumerable.Select<ClientData,·GameData.PlayerInfo>(Enumerable.OrderBy<ClientData,·int>(Enumerable.Where<ClientData>(Enumerable.Where<ClientData>(Enumerable.Where<ClientData>(list,·(ClientData·c)·=>·c.Character·!=·null),·(ClientData·c)·=>·c.Character.Data·!=·null),·(ClientData·c)·=>·!c.Character.Data.Disconnected·&&·!c.Character.Data.IsDead),·(ClientData·c)·=>·c.Id),·(ClientData·c)·=>·c.Character.Data));63 »       »       List<NetworkedPlayerInfo>·list2·=·Enumerable.ToList<NetworkedPlayerInfo>(Enumerable.Select<ClientData,·NetworkedPlayerInfo>(Enumerable.OrderBy<ClientData,·int>(Enumerable.Where<ClientData>(Enumerable.Where<ClientData>(Enumerable.Where<ClientData>(list,·(ClientData·c)·=>·c.Character·!=·null),·(ClientData·c)·=>·c.Character.Data·!=·null),·(ClientData·c)·=>·!c.Character.Data.Disconnected·&&·!c.Character.Data.IsDead),·(ClientData·c)·=>·c.Id),·(ClientData·c)·=>·c.Character.Data));
64 »       »       foreach·(GameData.PlayerInfo·playerInfo·in·GameData.Instance.AllPlayers)64 »       »       foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers)
65 »       »       {65 »       »       {
66 »       »       »       if·(playerInfo.Object·!=·null·&&·playerInfo.Object.isDummy)66 »       »       »       if·(networkedPlayerInfo.Object·!=·null·&&·networkedPlayerInfo.Object.isDummy)
67 »       »       »       {67 »       »       »       {
68 »       »       »       »       list2.Add(playerInfo);68 »       »       »       »       list2.Add(networkedPlayerInfo);
69 »       »       »       }69 »       »       »       }
70 »       »       }70 »       »       }
71 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions;71 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions;
72 »       »       int·adjustedNumImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.GetAdjustedNumImpostors(list2.Count);72 »       »       int·adjustedNumImpostors·=·GameOptionsManager.Instance.CurrentGameOptions.GetAdjustedNumImpostors(list2.Count);
73 »       »       this.DebugRoleAssignments(list2,·ref·adjustedNumImpostors);73 »       »       this.DebugRoleAssignments(list2,·ref·adjustedNumImpostors);
74 »       »       GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Impostor,·adjustedNumImpostors,·new·RoleTypes?(RoleTypes.Impostor));74 »       »       GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Impostor,·adjustedNumImpostors,·new·RoleTypes?(RoleTypes.Impostor));
75 »       »       GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Crewmate,·int.MaxValue,·new·RoleTypes?(RoleTypes.Crewmate));75 »       »       GameManager.Instance.LogicRoleSelection.AssignRolesForTeam(list2,·currentGameOptions,·RoleTeamTypes.Crewmate,·int.MaxValue,·new·RoleTypes?(RoleTypes.Crewmate));
Offset 83, 40 lines modifiedOffset 83, 40 lines modified
83 »       »       }83 »       »       }
84 »       »       if·(!player.Data.Role.IsImpostor·&&·specialRolesAllowed)84 »       »       if·(!player.Data.Role.IsImpostor·&&·specialRolesAllowed)
85 »       »       {85 »       »       {
86 »       »       »       RoleManager.TryAssignSpecialGhostRoles(player);86 »       »       »       RoleManager.TryAssignSpecialGhostRoles(player);
87 »       »       }87 »       »       }
88 »       »       if·(!RoleManager.IsGhostRole(player.Data.Role.Role))88 »       »       if·(!RoleManager.IsGhostRole(player.Data.Role.Role))
89 »       »       {89 »       »       {
90 »       »       »       player.RpcSetRole(player.Data.Role.DefaultGhostRole);90 »       »       »       player.RpcSetRole(player.Data.Role.DefaultGhostRole,·false);
91 »       »       }91 »       »       }
92 »       }92 »       }
93 93
94 »       private·void·DebugRoleAssignments(List<GameData.PlayerInfo>·players,·ref·int·numImpostors)94 »       private·void·DebugRoleAssignments(List<NetworkedPlayerInfo>·players,·ref·int·numImpostors)
95 »       {95 »       {
96 »       }96 »       }
97 97
98 »       private·static·void·TryAssignSpecialGhostRoles(PlayerControl·player)98 »       private·static·void·TryAssignSpecialGhostRoles(PlayerControl·player)
99 »       {99 »       {
100 »       »       RoleTypes·roleTypes·=·RoleTypes.GuardianAngel;100 »       »       RoleTypes·roleTypes·=·RoleTypes.GuardianAngel;
101 »       »       int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·pc)·=>·pc.Data.IsDead·&&·!pc.Data.Role.IsImpostor);101 »       »       int·num·=·Enumerable.Count<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·pc)·=>·pc.Data.IsDead·&&·!pc.Data.Role.IsImpostor);
102 »       »       IRoleOptionsCollection·roleOptions·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions;102 »       »       IRoleOptionsCollection·roleOptions·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions;
103 »       »       if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay)103 »       »       if·(AmongUsClient.Instance.NetworkMode·==·NetworkModes.FreePlay)
104 »       »       {104 »       »       {
105 »       »       »       player.RpcSetRole(roleTypes);105 »       »       »       player.RpcSetRole(roleTypes,·false);
106 »       »       »       return;106 »       »       »       return;
107 »       »       }107 »       »       }
108 »       »       if·(num·>·roleOptions.GetNumPerGame(roleTypes))108 »       »       if·(num·>·roleOptions.GetNumPerGame(roleTypes))
109 »       »       {109 »       »       {
110 »       »       »       return;110 »       »       »       return;
111 »       »       }111 »       »       }
112 »       »       int·chancePerGame·=·roleOptions.GetChancePerGame(roleTypes);112 »       »       int·chancePerGame·=·roleOptions.GetChancePerGame(roleTypes);
113 »       »       if·(HashRandom.Next(101)·<·chancePerGame)113 »       »       if·(HashRandom.Next(101)·<·chancePerGame)
114 »       »       {114 »       »       {
115 »       »       »       player.RpcSetRole(roleTypes);115 »       »       »       player.RpcSetRole(roleTypes,·false);
116 »       »       }116 »       »       }
117 »       }117 »       }
118 118
119 »       public·static·bool·IsGhostRole(RoleTypes·role)119 »       public·static·bool·IsGhostRole(RoleTypes·role)
120 »       {120 »       {
121 »       »       return·RoleManager.GhostRoles.Contains(role);121 »       »       return·RoleManager.GhostRoles.Contains(role);
122 »       }122 »       }
Offset 143, 14 lines modifiedOffset 143, 20 lines modified
143 143
144 »       public·RoleEffectAnimation·shapeshiftAnim;144 »       public·RoleEffectAnimation·shapeshiftAnim;
145 145
146 »       public·RoleEffectAnimation·protectAnim;146 »       public·RoleEffectAnimation·protectAnim;
147 147
148 »       public·RoleEffectAnimation·protectLoopAnim;148 »       public·RoleEffectAnimation·protectLoopAnim;
149 149
 150 »       public·RoleEffectAnimation·vanish_ChargeAnim;
 151
 152 »       public·RoleEffectAnimation·vanish_PoofAnim;
 153
 154 »       public·RoleEffectAnimation·appear_PoofAnim;
 155
150 »       public·class·RoleAssignmentData156 »       public·class·RoleAssignmentData
151 »       {157 »       {
152 »       »       public·RoleAssignmentData(RoleBehaviour·role,·int·count,·int·chance)158 »       »       public·RoleAssignmentData(RoleBehaviour·role,·int·count,·int·chance)
153 »       »       {159 »       »       {
154 »       »       »       this.Role·=·role;160 »       »       »       this.Role·=·role;
155 »       »       »       this.Count·=·count;161 »       »       »       this.Count·=·count;
156 »       »       »       this.Chance·=·chance;162 »       »       »       this.Chance·=·chance;
6.51 KB
Assembly-CSharp/RoleOptionSetting.cs
    
Offset 1, 98 lines modifiedOffset 1, 216 lines modified
1 using·System;1 using·System;
 2 using·System.Collections.Generic;
2 using·AmongUs.GameOptions;3 using·AmongUs.GameOptions;
3 using·TMPro;4 using·TMPro;
4 using·UnityEngine;5 using·UnityEngine;
5 6
6 public·class·RoleOptionSetting·:·OptionBehaviour7 public·class·RoleOptionSetting·:·OptionBehaviour
7 {8 {
 9 »       public·int·RoleMaxCount
 10 »       {
 11 »       »       get
 12 »       »       {
 13 »       »       »       return·this.roleMaxCount;
 14 »       »       }
 15 »       }
 16
 17 »       public·int·RoleChance
 18 »       {
 19 »       »       get
 20 »       »       {
 21 »       »       »       return·this.roleChance;
 22 »       »       }
 23 »       }
 24
 25 »       public·RoleBehaviour·Role
 26 »       {
 27 »       »       get
 28 »       »       {
 29 »       »       »       return·this.role;
 30 »       »       }
 31 »       }
 32
 33 »       public·List<PassiveButton>·ControllerSelectable
 34 »       {
 35 »       »       get
 36 »       »       {
 37 »       »       »       return·this.controllerSelectable;
 38 »       »       }
 39 »       }
 40
8 »       private·int·RoleMax41 »       private·int·RoleMax
9 »       {42 »       {
10 »       »       get43 »       »       get
11 »       »       {44 »       »       {
12 »       »       »       return·Mathf.Min(this.Role.MaxCount,·15);45 »       »       »       return·Mathf.Min(this.role.MaxCount,·15);
13 »       »       }46 »       »       }
14 »       }47 »       }
15 48
16 »       public·void·SetRole(IRoleOptionsCollection·options)49 »       public·void·SetRole(IRoleOptionsCollection·options,·RoleBehaviour·role,·int·maskLayer)
17 »       {50 »       {
 51 »       »       SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>(true);
 52 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)
 53 »       »       {
 54 »       »       »       componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·maskLayer);
 55 »       »       }
 56 »       »       foreach·(TextMeshPro·textMeshPro·in·base.GetComponentsInChildren<TextMeshPro>(true))
 57 »       »       {
 58 »       »       »       textMeshPro.fontMaterial.SetFloat("_StencilComp",·3f);
 59 »       »       »       textMeshPro.fontMaterial.SetFloat("_Stencil",·(float)maskLayer);
 60 »       »       }
 61 »       »       this.role·=·role;
18 »       »       this.TitleText.text·=·this.Role.NiceName;62 »       »       this.titleText.text·=·this.role.NiceName;
 63 »       »       if·(role.TeamType·==·RoleTeamTypes.Crewmate)
 64 »       »       {
 65 »       »       »       this.labelSprite.color·=·Palette.CrewmateRoleBlue;
 66 »       »       }
 67 »       »       else
 68 »       »       {
 69 »       »       »       this.labelSprite.color·=·Palette.ImpostorRoleRed;
 70 »       »       }
19 »       »       this.UpdateValuesAndText(options);71 »       »       this.UpdateValuesAndText(options);
 72 »       »       this.AdjustCountButtonsActiveState();
 73 »       »       this.AdjustChanceButtonsActiveState();
20 »       }74 »       }
21 75
22 »       public·void·UpdateValuesAndText(IRoleOptionsCollection·options)76 »       public·void·UpdateValuesAndText(IRoleOptionsCollection·options)
23 »       {77 »       {
24 »       »       this.RoleMaxCount·=·options.GetNumPerGame(this.Role.Role);78 »       »       this.roleMaxCount·=·options.GetNumPerGame(this.role.Role);
25 »       »       this.RoleChance·=·options.GetChancePerGame(this.Role.Role);79 »       »       this.roleChance·=·options.GetChancePerGame(this.role.Role);
26 »       »       this.CountText.text·=·this.RoleMaxCount.ToString();80 »       »       this.countText.text·=·this.roleMaxCount.ToString();
27 »       »       this.ChanceText.text·=·this.RoleChance.ToString()·+·"%";81 »       »       this.chanceText.text·=·this.roleChance.ToString();
28 »       }82 »       }
29 83
30 »       public·void·IncreaseCount()84 »       public·void·IncreaseCount()
31 »       {85 »       {
 86 »       »       if·(this.roleMaxCount·>=·this.role.MaxCount)
 87 »       »       {
 88 »       »       »       return;
 89 »       »       }
32 »       »       if·(this.RoleMaxCount·==·0)90 »       »       if·(this.roleMaxCount·==·0)
33 »       »       {91 »       »       {
34 »       »       »       this.RoleChance·=·50;92 »       »       »       this.roleChance·=·50;
 93 »       »       »       this.AdjustChanceButtonsActiveState();
35 »       »       }94 »       »       }
36 »       »       this.RoleMaxCount·=·Mathf.Clamp(this.RoleMaxCount·+·1,·0,·this.RoleMax);95 »       »       this.roleMaxCount·=·Mathf.Clamp(this.roleMaxCount·+·1,·0,·this.RoleMax);
37 »       »       this.OnValueChanged(this);96 »       »       this.OnValueChanged(this);
38 »       »       this.ShowRoleDetails();97 »       »       this.AdjustCountButtonsActiveState();
39 »       }98 »       }
40 99
41 »       public·void·DecreaseCount()100 »       public·void·DecreaseCount()
42 »       {101 »       {
43 »       »       this.RoleMaxCount·=·Mathf.Clamp(this.RoleMaxCount·-·1,·0,·this.RoleMax); 
44 »       »       if·(this.RoleMaxCount·==·0)102 »       »       if·(this.roleMaxCount·==·0)
45 »       »       {103 »       »       {
 104 »       »       »       return;
 105 »       »       }
 106 »       »       this.roleMaxCount·=·Mathf.Clamp(this.roleMaxCount·-·1,·0,·this.RoleMax);
 107 »       »       if·(this.roleMaxCount·==·0)
 108 »       »       {
46 »       »       »       this.RoleChance·=·0;109 »       »       »       this.roleChance·=·0;
 110 »       »       »       this.AdjustChanceButtonsActiveState();
47 »       »       }111 »       »       }
48 »       »       this.OnValueChanged(this);112 »       »       this.OnValueChanged(this);
49 »       »       this.ShowRoleDetails();113 »       »       this.AdjustCountButtonsActiveState();
50 »       }114 »       }
51 115
52 »       public·void·IncreaseChance()116 »       public·void·IncreaseChance()
53 »       {117 »       {
 118 »       »       if·(this.roleChance·>=·100)
 119 »       »       {
 120 »       »       »       return;
 121 »       »       }
54 »       »       if·(this.RoleChance·==·0)122 »       »       if·(this.roleChance·==·0)
55 »       »       {123 »       »       {
56 »       »       »       this.RoleMaxCount·=·1;124 »       »       »       this.roleMaxCount·=·1;
 125 »       »       »       this.AdjustCountButtonsActiveState();
57 »       »       }126 »       »       }
Max diff block lines reached; 2728/6593 bytes (41.38%) of diff not shown.
24.2 KB
Assembly-CSharp/RolesSettingsMenu.cs
    
Offset 1, 187 lines modifiedOffset 1, 537 lines modified
1 using·System;1 using·System;
2 using·System.Collections.Generic;2 using·System.Collections.Generic;
3 using·AmongUs.GameOptions;3 using·AmongUs.GameOptions;
 4 using·Rewired;
 5 using·TMPro;
4 using·UnityEngine;6 using·UnityEngine;
5 7
6 public·class·RolesSettingsMenu·:·MonoBehaviour8 public·class·RolesSettingsMenu·:·MonoBehaviour
7 {9 {
8 »       private·void·Start()10 »       private·void·Awake()
9 »       {11 »       {
10 »       »       this.Children·=·base.GetComponentsInChildren<OptionBehaviour>(true); 
11 »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions;12 »       »       this.MaskBg.material.SetInt(PlayerMaterial.MaskLayer,·20);
 13 »       »       this.MaskArea.material.SetInt(PlayerMaterial.MaskLayer,·20);
 14 »       »       this.quotaHeader.SetHeader(StringNames.RoleQuotaLabel,·20);
 15 »       »       this.advHeader.SetHeader(StringNames.RoleSettingsLabel,·20);
 16 »       }
 17
 18 »       private·void·InitialSetup()
 19 »       {
 20 »       »       this.QuotaTabSelectables·=·new·List<UiElement>();
 21 »       »       this.advancedSettingChildren·=·new·List<OptionBehaviour>();
 22 »       »       this.roleChances·=·new·List<RoleOptionSetting>();
 23 »       »       this.SetQuotaTab();
 24 »       }
 25
 26 »       private·void·OnEnable()
 27 »       {
 28 »       »       this.RoleChancesSettings.SetActive(true);
 29 »       »       this.AdvancedRolesSettings.SetActive(false);
 30 »       »       this.RefreshChildren();
 31 »       »       SpriteRenderer[]·componentsInChildren·=·this.AdvancedRolesSettings.GetComponentsInChildren<SpriteRenderer>(true);
12 »       »       for·(int·i·=·0;·i·<·this.Children.Length;·i++)32 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)
13 »       »       {33 »       »       {
 34 »       »       »       componentsInChildren[i].material.SetInt(PlayerMaterial.MaskLayer,·20);
14 »       »       »       OptionBehaviour·optionBehaviour·=·this.Children[i]; 
15 »       »       »       optionBehaviour.OnValueChanged·=·new·Action<OptionBehaviour>(this.ValueChanged); 
16 »       »       »       if·(AmongUsClient.Instance·&&·!AmongUsClient.Instance.AmHost) 
17 »       »       »       { 
18 »       »       »       »       optionBehaviour.SetAsPlayer(); 
19 »       »       »       }35 »       »       }
 36 »       »       foreach·(TextMeshPro·textMeshPro·in·this.AdvancedRolesSettings.GetComponentsInChildren<TextMeshPro>(true))
 37 »       »       {
 38 »       »       »       textMeshPro.fontMaterial.SetFloat("_StencilComp",·3f);
 39 »       »       »       textMeshPro.fontMaterial.SetFloat("_Stencil",·20f);
20 »       »       }40 »       »       }
21 »       }41 »       }
22 42
 43 »       private·void·OnDisable()
 44 »       {
 45 »       »       this.CloseMenu();
 46 »       }
 47
 48 »       public·void·OpenMenu()
 49 »       {
 50 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.DefaultButtonSelected,·this.ControllerSelectable,·false);
 51 »       »       this.EnableTabControllerGlyphs(true);
 52 »       »       this.OpenChancesTab();
 53 »       }
 54
 55 »       public·void·CloseMenu()
 56 »       {
 57 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);
 58 »       »       this.EnableTabControllerGlyphs(false);
 59 »       }
 60
23 »       private·void·Update()61 »       private·void·Update()
24 »       {62 »       {
25 »       »       if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions)63 »       »       if·(this.cachedData·!=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions)
26 »       »       {64 »       »       {
27 »       »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions;65 »       »       »       this.cachedData·=·GameOptionsManager.Instance.CurrentGameOptions.RoleOptions;
28 »       »       »       this.RefreshChildren();66 »       »       »       this.RefreshChildren();
29 »       »       }67 »       »       }
 68 »       »       if·(ControllerManager.Instance.CurrentUiState.MenuName·==·base.name)
 69 »       »       {
 70 »       »       »       Player·player·=·ReInput.players.GetPlayer(0);
 71 »       »       »       bool·flag·=·false;
 72 »       »       »       if·(this.selectedRoleTab·>·0·&&·player.GetButtonDown(35))
 73 »       »       »       {
 74 »       »       »       »       this.selectedRoleTab--;
 75 »       »       »       »       flag·=·true;
 76 »       »       »       }
 77 »       »       »       if·(this.selectedRoleTab·<·this.roleTabs.Count·-·1·&&·player.GetButtonDown(34))
 78 »       »       »       {
 79 »       »       »       »       this.selectedRoleTab++;
 80 »       »       »       »       flag·=·true;
 81 »       »       »       }
 82 »       »       »       if·(flag)
 83 »       »       »       {
 84 »       »       »       »       if·(this.selectedRoleTab·==·0)
 85 »       »       »       »       {
 86 »       »       »       »       »       this.OpenChancesTab();
 87 »       »       »       »       }
 88 »       »       »       »       else
 89 »       »       »       »       {
 90 »       »       »       »       »       this.roleTabs[this.selectedRoleTab].OnClick.Invoke();
 91 »       »       »       »       }
 92 »       »       »       }
 93 »       »       »       if·(this.selectedRoleTab·>·0)
 94 »       »       »       {
 95 »       »       »       »       this.glyphL.color·=·Color.white;
 96 »       »       »       }
 97 »       »       »       else
 98 »       »       »       {
 99 »       »       »       »       this.glyphL.color·=·this.glyphUnavailableColor;
 100 »       »       »       }
 101 »       »       »       if·(this.selectedRoleTab·<·this.roleTabs.Count·-·1)
 102 »       »       »       {
 103 »       »       »       »       this.glyphR.color·=·Color.white;
 104 »       »       »       »       return;
 105 »       »       »       }
 106 »       »       »       this.glyphR.color·=·this.glyphUnavailableColor;
 107 »       »       }
30 »       }108 »       }
31 109
32 »       private·void·OnEnable()110 »       private·void·AddRoleTab(RoleRulesCategory·cat,·ref·float·tabXPos)
 111 »       {
 112 »       »       RoleSettingsTabButton·tab;
 113 »       »       if·(cat.Role.TeamType·==·RoleTeamTypes.Crewmate)
 114 »       »       {
 115 »       »       »       tab·=·Object.Instantiate<RoleSettingsTabButton>(this.roleSettingsTabButtonOrigin,·Vector3.zero,·Quaternion.identity,·this.tabParent);
 116 »       »       }
 117 »       »       else
 118 »       »       {
 119 »       »       »       tab·=·Object.Instantiate<RoleSettingsTabButton>(this.roleSettingsTabButtonOriginImpostor,·Vector3.zero,·Quaternion.identity,·this.tabParent);
 120 »       »       }
 121 »       »       tab.transform.localPosition·=·new·Vector3(tabXPos,·2.27f,·-2f);
Max diff block lines reached; 18565/24696 bytes (75.17%) of diff not shown.
457 B
Assembly-CSharp/RoleTypeHelpers.cs
    
Offset 33, 10 lines modifiedOffset 33, 22 lines modified
33 »       »       {33 »       »       {
34 »       »       »       RoleTypes.CrewmateGhost,34 »       »       »       RoleTypes.CrewmateGhost,
35 »       »       »       StringNames.CrewmateGhostRole35 »       »       »       StringNames.CrewmateGhostRole
36 »       »       },36 »       »       },
37 »       »       {37 »       »       {
38 »       »       »       RoleTypes.ImpostorGhost,38 »       »       »       RoleTypes.ImpostorGhost,
39 »       »       »       StringNames.ImpostorGhostRole39 »       »       »       StringNames.ImpostorGhostRole
 40 »       »       },
 41 »       »       {
 42 »       »       »       RoleTypes.Noisemaker,
 43 »       »       »       StringNames.NoisemakerRole
 44 »       »       },
 45 »       »       {
 46 »       »       »       RoleTypes.Phantom,
 47 »       »       »       StringNames.PhantomRole
 48 »       »       },
 49 »       »       {
 50 »       »       »       RoleTypes.Tracker,
 51 »       »       »       StringNames.TrackerRole
40 »       »       }52 »       »       }
41 »       };53 »       };
42 }54 }
314 B
Assembly-CSharp/RpcCalls.cs
    
Offset 54, 9 lines modifiedOffset 54, 13 lines modified
54 »       CheckZipline,54 »       CheckZipline,
55 »       UseZipline,55 »       UseZipline,
56 »       TriggerSpores,56 »       TriggerSpores,
57 »       CheckSpore,57 »       CheckSpore,
58 »       CheckShapeshift,58 »       CheckShapeshift,
59 »       RejectShapeshift,59 »       RejectShapeshift,
60 »       LobbyTimeExpiring·=·60,60 »       LobbyTimeExpiring·=·60,
61 »       ExtendLobbyTimer61 »       ExtendLobbyTimer,
 62 »       CheckVanish,
 63 »       StartVanish,
 64 »       CheckAppear,
 65 »       StartAppear
62 }66 }
502 B
Assembly-CSharp/SabotageButton.cs
    
Offset 11, 15 lines modifiedOffset 11, 15 lines modified
11 »       »       »       »       Mode·=·MapOptions.Modes.Sabotage11 »       »       »       »       Mode·=·MapOptions.Modes.Sabotage
12 »       »       »       });12 »       »       »       });
13 »       »       }13 »       »       }
14 »       }14 »       }
15 15
16 »       public·void·Refresh()16 »       public·void·Refresh()
17 »       {17 »       {
18 »       »       if·(GameManager.Instance·==·null)18 »       »       if·(GameManager.Instance·==·null·||·PlayerControl.LocalPlayer·==·null)
19 »       »       {19 »       »       {
20 »       »       »       base.ToggleVisible(false);20 »       »       »       base.ToggleVisible(false);
21 »       »       »       base.SetDisabled();21 »       »       »       base.SetDisabled();
22 »       »       »       return;22 »       »       »       return;
23 »       »       }23 »       »       }
24 »       »       if·(PlayerControl.LocalPlayer.inVent·||·!GameManager.Instance.SabotagesEnabled()·||·PlayerControl.LocalPlayer.petting)24 »       »       if·(PlayerControl.LocalPlayer.inVent·||·!GameManager.Instance.SabotagesEnabled()·||·PlayerControl.LocalPlayer.petting)
25 »       »       {25 »       »       {
2.09 KB
Assembly-CSharp/SampleMinigame.cs
    
Offset 72, 14 lines modifiedOffset 72, 15 lines modified
72 »       »       {72 »       »       {
73 »       »       »       for·(int·j·=·0;·j·<·this.Tubes.Length;·j++)73 »       »       »       for·(int·j·=·0;·j·<·this.Tubes.Length;·j++)
74 »       »       »       {74 »       »       »       {
75 »       »       »       »       this.Tubes[j].color·=·Color.blue;75 »       »       »       »       this.Tubes[j].color·=·Color.blue;
76 »       »       »       }76 »       »       »       }
77 »       »       »       this.Tubes[this.AnomalyId].color·=·Color.red;77 »       »       »       this.Tubes[this.AnomalyId].color·=·Color.red;
78 »       »       »       this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>());78 »       »       »       this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>());
 79 »       »       »       this.phase1_controllerGlyph.SetActive(false);
79 »       »       »       this.SetPlatformTop();80 »       »       »       this.SetPlatformTop();
80 »       »       }81 »       »       }
81 »       »       base.SetupInput(true,·false);82 »       »       base.SetupInput(true,·false);
82 »       }83 »       }
83 84
84 »       private·void·SetPlatformBottom()85 »       private·void·SetPlatformBottom()
85 »       {86 »       {
Offset 169, 14 lines modifiedOffset 170, 15 lines modified
169 170
170 »       public·void·FixedUpdate()171 »       public·void·FixedUpdate()
171 »       {172 »       {
172 »       »       if·(this.State·==·SampleMinigame.States.Processing)173 »       »       if·(this.State·==·SampleMinigame.States.Processing)
173 »       »       {174 »       »       {
174 »       »       »       if·(this.MyNormTask.TaskTimer·<=·0f)175 »       »       »       if·(this.MyNormTask.TaskTimer·<=·0f)
175 »       »       »       {176 »       »       »       {
 177 »       »       »       »       this.phase1_controllerGlyph.SetActive(false);
176 »       »       »       »       this.State·=·SampleMinigame.States.Selection;178 »       »       »       »       this.State·=·SampleMinigame.States.Selection;
177 »       »       »       »       this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>());179 »       »       »       »       this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesSelect,·Array.Empty<object>());
178 »       »       »       »       this.UpperText.text·=·"";180 »       »       »       »       this.UpperText.text·=·"";
179 »       »       »       »       this.AnomalyId·=·this.Tubes.RandomIdx<SpriteRenderer>();181 »       »       »       »       this.AnomalyId·=·this.Tubes.RandomIdx<SpriteRenderer>();
180 »       »       »       »       this.Tubes[this.AnomalyId].color·=·Color.red;182 »       »       »       »       this.Tubes[this.AnomalyId].color·=·Color.red;
181 »       »       »       »       SpriteRenderer[]·array·=·this.LowerButtons;183 »       »       »       »       SpriteRenderer[]·array·=·this.LowerButtons;
182 »       »       »       »       for·(int·i·=·0;·i·<·array.Length;·i++)184 »       »       »       »       for·(int·i·=·0;·i·<·array.Length;·i++)
Offset 228, 14 lines modifiedOffset 230, 15 lines modified
228 »       »       »       pos.y·=·this.platformY.Lerp(i·/·0.75f);230 »       »       »       pos.y·=·this.platformY.Lerp(i·/·0.75f);
229 »       »       »       this.CenterPanel.transform.localPosition·=·pos;231 »       »       »       this.CenterPanel.transform.localPosition·=·pos;
230 »       »       »       yield·return·wait;232 »       »       »       yield·return·wait;
231 »       »       }233 »       »       }
232 »       »       if·(isBeginning)234 »       »       if·(isBeginning)
233 »       »       {235 »       »       {
234 »       »       »       this.State·=·SampleMinigame.States.AwaitingStart;236 »       »       »       this.State·=·SampleMinigame.States.AwaitingStart;
 237 »       »       »       this.phase1_controllerGlyph.SetActive(true);
235 »       »       »       this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesPress,·Array.Empty<object>()).PadRight(19,·'·')·+·"·-->";238 »       »       »       this.LowerText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SamplesPress,·Array.Empty<object>()).PadRight(19,·'·')·+·"·-->";
236 »       »       }239 »       »       }
237 »       »       pos.y·=·this.platformY.max;240 »       »       pos.y·=·this.platformY.max;
238 »       »       this.CenterPanel.transform.localPosition·=·pos;241 »       »       this.CenterPanel.transform.localPosition·=·pos;
239 »       »       yield·break;242 »       »       yield·break;
240 »       }243 »       }
241 244
Offset 461, 14 lines modifiedOffset 464, 17 lines modified
461 464
462 »       private·RandomFill<AudioClip>·dropSounds;465 »       private·RandomFill<AudioClip>·dropSounds;
463 466
464 »       public·Transform·whichButtonSelector;467 »       public·Transform·whichButtonSelector;
465 468
466 »       public·int·whichButtonSelected·=·2;469 »       public·int·whichButtonSelected·=·2;
467 470
 471 »       [SerializeField]
 472 »       private·GameObject·phase1_controllerGlyph;
 473
468 »       private·float·selectMoveCooldown;474 »       private·float·selectMoveCooldown;
469 475
470 »       public·enum·States·:·byte476 »       public·enum·States·:·byte
471 »       {477 »       {
472 »       »       PrepareSample,478 »       »       PrepareSample,
473 »       »       Complete·=·16,479 »       »       Complete·=·16,
474 »       »       AwaitingStart·=·32,480 »       »       AwaitingStart·=·32,
721 B
Assembly-CSharp/SceneChanger.cs
    
Offset 1, 9 lines modifiedOffset 1, 8 lines modified
1 using·System;1 using·System;
2 using·AmongUs.Data; 
3 using·UnityEngine;2 using·UnityEngine;
4 using·UnityEngine.SceneManagement;3 using·UnityEngine.SceneManagement;
5 using·UnityEngine.UI;4 using·UnityEngine.UI;
6 5
7 public·class·SceneChanger·:·MonoBehaviour6 public·class·SceneChanger·:·MonoBehaviour
8 {7 {
9 »       public·void·Click()8 »       public·void·Click()
Offset 64, 20 lines modifiedOffset 63, 14 lines modified
64 »       private·bool·AllowSceneChange()63 »       private·bool·AllowSceneChange()
65 »       {64 »       {
66 »       »       return·this.CheckHowToPlay();65 »       »       return·this.CheckHowToPlay();
67 »       }66 »       }
68 67
69 »       private·bool·CheckHowToPlay()68 »       private·bool·CheckHowToPlay()
70 »       {69 »       {
71 »       »       if·(!DataManager.Player.Onboarding.ViewedHideAndSeekHowToPlay) 
72 »       »       { 
73 »       »       »       HowToPlayScene.SceneOnClose·=·this.TargetScene; 
74 »       »       »       SceneManager.LoadScene("HowToPlay"); 
75 »       »       »       return·false; 
76 »       »       } 
77 »       »       return·true;70 »       »       return·true;
78 »       }71 »       }
79 72
80 »       public·string·TargetScene;73 »       public·string·TargetScene;
81 74
82 »       public·bool·disallowBasedOnSwitchParentalControls;75 »       public·bool·disallowBasedOnSwitchParentalControls;
83 76
620 B
Assembly-CSharp/ScientistRole.cs
    
Offset 115, 15 lines modifiedOffset 115, 15 lines modified
115 »       »       this.minigame.transform.localPosition·=·new·Vector3(0f,·0f,·-50f);115 »       »       this.minigame.transform.localPosition·=·new·Vector3(0f,·0f,·-50f);
116 »       »       this.minigame.BatteryText.gameObject.SetActive(true);116 »       »       this.minigame.BatteryText.gameObject.SetActive(true);
117 »       »       this.minigame.Begin(null);117 »       »       this.minigame.Begin(null);
118 »       }118 »       }
119 119
120 »       public·override·bool·CanUse(IUsable·console)120 »       public·override·bool·CanUse(IUsable·console)
121 »       {121 »       {
122 »       »       return·console·is·Console;122 »       »       return·console·is·ZiplineConsole·||·console·is·Ladder·||·console·is·PlatformConsole·||·console·is·Console·||·console·is·DoorConsole;
123 »       }123 »       }
124 124
125 »       public·override·bool·DidWin(GameOverReason·gameOverReason)125 »       public·override·bool·DidWin(GameOverReason·gameOverReason)
126 »       {126 »       {
127 »       »       return·GameManager.Instance.DidHumansWin(gameOverReason);127 »       »       return·GameManager.Instance.DidHumansWin(gameOverReason);
128 »       }128 »       }
129 129
495 B
Assembly-CSharp/Scroller.cs
Ordering differences only
    
Offset 322, 16 lines modifiedOffset 322, 16 lines modified
322 322
323 »       public·Transform·Inner;323 »       public·Transform·Inner;
324 324
325 »       public·bool·allowY;325 »       public·bool·allowY;
326 326
327 »       public·bool·showY·=·true;327 »       public·bool·showY·=·true;
328 328
329 »       [SerializeField] 
330 »       [FormerlySerializedAs("YBounds")]329 »       [FormerlySerializedAs("YBounds")]
 330 »       [SerializeField]
331 »       private·FloatRange·ContentYBounds·=·new·FloatRange(-10f,·10f);331 »       private·FloatRange·ContentYBounds·=·new·FloatRange(-10f,·10f);
332 332
333 »       [FormerlySerializedAs("ScrollerYRange")]333 »       [FormerlySerializedAs("ScrollerYRange")]
334 »       public·FloatRange·ScrollbarYBounds;334 »       public·FloatRange·ScrollbarYBounds;
335 335
336 »       [FormerlySerializedAs("ScrollerY")]336 »       [FormerlySerializedAs("ScrollerY")]
337 »       public·Scrollbar·ScrollbarY;337 »       public·Scrollbar·ScrollbarY;
541 B
Assembly-CSharp/SecurityCameraSystemType.cs
    
Offset 16, 15 lines modifiedOffset 16, 15 lines modified
16 16
17 »       public·void·Deteriorate(float·deltaTime)17 »       public·void·Deteriorate(float·deltaTime)
18 »       {18 »       {
19 »       »       if·(GameData.Instance)19 »       »       if·(GameData.Instance)
20 »       »       {20 »       »       {
21 »       »       »       foreach·(byte·b·in·this.PlayersUsing)21 »       »       »       foreach·(byte·b·in·this.PlayersUsing)
22 »       »       »       {22 »       »       »       {
23 »       »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(b);23 »       »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(b);
24 »       »       »       »       if·(playerById·==·null·||·playerById.Disconnected)24 »       »       »       »       if·(playerById·==·null·||·playerById.Disconnected)
25 »       »       »       »       {25 »       »       »       »       {
26 »       »       »       »       »       this.ToRemove.Add(b);26 »       »       »       »       »       this.ToRemove.Add(b);
27 »       »       »       »       }27 »       »       »       »       }
28 »       »       »       }28 »       »       »       }
29 »       »       »       if·(this.ToRemove.Count·>·0)29 »       »       »       if·(this.ToRemove.Count·>·0)
30 »       »       »       {30 »       »       »       {
913 B
Assembly-CSharp/SecurityLogger.cs
    
Offset 24, 15 lines modifiedOffset 24, 15 lines modified
24 »       »       }24 »       »       }
25 »       »       int·num·=·this.Sensor.OverlapCollider(this.filter,·SecurityLogger.hits);25 »       »       int·num·=·this.Sensor.OverlapCollider(this.filter,·SecurityLogger.hits);
26 »       »       int·i;26 »       »       int·i;
27 »       »       int·num2;27 »       »       int·num2;
28 »       »       for·(i·=·0;·i·<·num;·i·=·num2)28 »       »       for·(i·=·0;·i·<·num;·i·=·num2)
29 »       »       {29 »       »       {
30 »       »       »       PlayerControl·playerControl·=·Enumerable.FirstOrDefault<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.Collider·==·SecurityLogger.hits[i]);30 »       »       »       PlayerControl·playerControl·=·Enumerable.FirstOrDefault<PlayerControl>(PlayerControl.AllPlayerControls,·(PlayerControl·p)·=>·p.Collider·==·SecurityLogger.hits[i]);
31 »       »       »       if·(playerControl·&&·playerControl.Data·!=·null·&&·!playerControl.Data.IsDead·&&·this.Timers[(int)playerControl.PlayerId]·<·0f)31 »       »       »       if·(playerControl·&&·!(playerControl.Data·==·null)·&&·!playerControl.Data.IsDead·&&·this.Timers[(int)playerControl.PlayerId]·<·0f)
32 »       »       »       {32 »       »       »       {
33 »       »       »       »       this.Timers[(int)playerControl.PlayerId]·=·this.Cooldown;33 »       »       »       »       this.Timers[(int)playerControl.PlayerId]·=·this.Cooldown;
34 »       »       »       »       this.LogParent.LogPlayer(playerControl,·this.MyLocation);34 »       »       »       »       this.LogParent.LogPlayer(playerControl,·this.MyLocation);
35 »       »       »       »       base.StopAllCoroutines();35 »       »       »       »       base.StopAllCoroutines();
36 »       »       »       »       base.StartCoroutine(this.BlinkSensor());36 »       »       »       »       base.StartCoroutine(this.BlinkSensor());
37 »       »       »       }37 »       »       »       }
38 »       »       »       num2·=·i·+·1;38 »       »       »       num2·=·i·+·1;
586 B
Assembly-CSharp/ServerManager.cs
Ordering differences only
    
Offset 320, 16 lines modifiedOffset 320, 16 lines modified
320 320
321 »       private·const·float·PingTimeoutSeconds·=·5f;321 »       private·const·float·PingTimeoutSeconds·=·5f;
322 322
323 »       private·string·serverInfoFileJson;323 »       private·string·serverInfoFileJson;
324 324
325 »       private·UpdateState·state;325 »       private·UpdateState·state;
326 326
327 »       [Skip] 
328 »       [JsonObject]327 »       [JsonObject]
 328 »       [Skip]
329 »       private·struct·JsonServerData329 »       private·struct·JsonServerData
330 »       {330 »       {
331 »       »       internal·void·CleanAndMerge(IRegionInfo[]·defaultRegions)331 »       »       internal·void·CleanAndMerge(IRegionInfo[]·defaultRegions)
332 »       »       {332 »       »       {
333 »       »       »       List<IRegionInfo>·list·=·Enumerable.ToList<IRegionInfo>(Enumerable.Where<IRegionInfo>(this.Regions,·(IRegionInfo·r)·=>·r.Validate()));333 »       »       »       List<IRegionInfo>·list·=·Enumerable.ToList<IRegionInfo>(Enumerable.Where<IRegionInfo>(this.Regions,·(IRegionInfo·r)·=>·r.Validate()));
334 »       »       »       for·(int·i·=·defaultRegions.Length·-·1;·i·>=·0;·i--)334 »       »       »       for·(int·i·=·defaultRegions.Length·-·1;·i·>=·0;·i--)
335 »       »       »       {335 »       »       »       {
657 B
Assembly-CSharp/ShapeshifterPanel.cs
    
Offset 1, 15 lines modifiedOffset 1, 15 lines modified
1 using·System;1 using·System;
2 using·AmongUs.Data;2 using·AmongUs.Data;
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·ShapeshifterPanel·:·MonoBehaviour6 public·class·ShapeshifterPanel·:·MonoBehaviour
7 {7 {
8 »       public·void·SetPlayer(int·index,·GameData.PlayerInfo·playerInfo,·Action·onShift)8 »       public·void·SetPlayer(int·index,·NetworkedPlayerInfo·playerInfo,·Action·onShift)
9 »       {9 »       {
10 »       »       this.shapeshift·=·onShift;10 »       »       this.shapeshift·=·onShift;
11 »       »       this.PlayerIcon.SetFlipX(false);11 »       »       this.PlayerIcon.SetFlipX(false);
12 »       »       this.PlayerIcon.ToggleName(false);12 »       »       this.PlayerIcon.ToggleName(false);
13 »       »       SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>();13 »       »       SpriteRenderer[]·componentsInChildren·=·base.GetComponentsInChildren<SpriteRenderer>();
14 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)14 »       »       for·(int·i·=·0;·i·<·componentsInChildren.Length;·i++)
15 »       »       {15 »       »       {
6.14 KB
Assembly-CSharp/ShipStatus.cs
    
Offset 207, 15 lines modifiedOffset 207, 14 lines modified
207 207
208 »       protected·virtual·void·Start()208 »       protected·virtual·void·Start()
209 »       {209 »       {
210 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)210 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
211 »       »       {211 »       »       {
212 »       »       »       DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed();212 »       »       »       DestroyableSingleton<HudManager>.Instance.Chat.ForceClosed();
213 »       »       »       DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(false);213 »       »       »       DestroyableSingleton<HudManager>.Instance.Chat.SetVisible(false);
214 »       »       »       DestroyableSingleton<HudManager>.Instance.GameSettings.gameObject.SetActive(false); 
215 »       »       }214 »       »       }
216 »       »       foreach·(DeconSystem·deconSystem·in·base.GetComponentsInChildren<DeconSystem>())215 »       »       foreach·(DeconSystem·deconSystem·in·base.GetComponentsInChildren<DeconSystem>())
217 »       »       {216 »       »       {
218 »       »       »       this.Systems.Add(deconSystem.TargetSystem,·deconSystem);217 »       »       »       this.Systems.Add(deconSystem.TargetSystem,·deconSystem);
219 »       »       }218 »       »       }
220 »       }219 »       }
221 220
Offset 383, 15 lines modifiedOffset 382, 15 lines modified
383 »       }382 »       }
384 383
385 »       public·void·Begin()384 »       public·void·Begin()
386 »       {385 »       {
387 »       »       this.numScans·=·0;386 »       »       this.numScans·=·0;
388 »       »       this.AssignTaskIndexes();387 »       »       this.AssignTaskIndexes();
389 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions;388 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions;
390 »       »       List<GameData.PlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers;389 »       »       List<NetworkedPlayerInfo>·allPlayers·=·GameData.Instance.AllPlayers;
391 »       »       HashSet<TaskTypes>·hashSet·=·new·HashSet<TaskTypes>();390 »       »       HashSet<TaskTypes>·hashSet·=·new·HashSet<TaskTypes>();
392 »       »       List<byte>·list·=·new·List<byte>(10);391 »       »       List<byte>·list·=·new·List<byte>(10);
393 »       »       List<NormalPlayerTask>·list2·=·Enumerable.ToList<NormalPlayerTask>(this.CommonTasks);392 »       »       List<NormalPlayerTask>·list2·=·Enumerable.ToList<NormalPlayerTask>(this.CommonTasks);
394 »       »       list2.Shuffle(0);393 »       »       list2.Shuffle(0);
395 »       »       list2.ForEach(delegate(NormalPlayerTask·t)394 »       »       list2.ForEach(delegate(NormalPlayerTask·t)
396 »       »       {395 »       »       {
397 »       »       »       t.Length·=·NormalPlayerTask.TaskLength.Common;396 »       »       »       t.Length·=·NormalPlayerTask.TaskLength.Common;
Offset 434, 19 lines modifiedOffset 433, 19 lines modified
434 »       »       byte·b·=·0;433 »       »       byte·b·=·0;
435 »       »       while·((int)b·<·allPlayers.Count)434 »       »       while·((int)b·<·allPlayers.Count)
436 »       »       {435 »       »       {
437 »       »       »       hashSet.Clear();436 »       »       »       hashSet.Clear();
438 »       »       »       list.RemoveRange(int2,·list.Count·-·int2);437 »       »       »       list.RemoveRange(int2,·list.Count·-·int2);
439 »       »       »       this.AddTasksFromList(ref·num3,·int3,·list,·hashSet,·list3);438 »       »       »       this.AddTasksFromList(ref·num3,·int3,·list,·hashSet,·list3);
440 »       »       »       this.AddTasksFromList(ref·num4,·num5,·list,·hashSet,·list4);439 »       »       »       this.AddTasksFromList(ref·num4,·num5,·list,·hashSet,·list4);
441 »       »       »       GameData.PlayerInfo·playerInfo·=·allPlayers[(int)b];440 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·allPlayers[(int)b];
442 »       »       »       if·(playerInfo.Object·&&·!playerInfo.Object.GetComponent<DummyBehaviour>().enabled)441 »       »       »       if·(networkedPlayerInfo.Object·&&·!networkedPlayerInfo.Object.GetComponent<DummyBehaviour>().enabled)
443 »       »       »       {442 »       »       »       {
444 »       »       »       »       byte[]·array·=·list.ToArray();443 »       »       »       »       byte[]·array·=·list.ToArray();
445 »       »       »       »       GameData.Instance.RpcSetTasks(playerInfo.PlayerId,·array);444 »       »       »       »       networkedPlayerInfo.RpcSetTasks(array);
446 »       »       »       }445 »       »       »       }
447 »       »       »       b·+=·1;446 »       »       »       b·+=·1;
448 »       »       }447 »       »       }
449 »       »       PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer();448 »       »       PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer();
450 »       }449 »       }
451 450
452 »       private·void·AddTasksFromList(ref·int·start,·int·count,·List<byte>·tasks,·HashSet<TaskTypes>·usedTaskTypes,·List<NormalPlayerTask>·unusedTasks)451 »       private·void·AddTasksFromList(ref·int·start,·int·count,·List<byte>·tasks,·HashSet<TaskTypes>·usedTaskTypes,·List<NormalPlayerTask>·unusedTasks)
Offset 521, 15 lines modifiedOffset 520, 15 lines modified
521 »       »       »       »       {520 »       »       »       »       {
522 »       »       »       »       »       systemType.Deteriorate(Time.fixedDeltaTime);521 »       »       »       »       »       systemType.Deteriorate(Time.fixedDeltaTime);
523 »       »       »       »       }522 »       »       »       »       }
524 »       »       »       }523 »       »       »       }
525 »       »       }524 »       »       }
526 »       }525 »       }
527 526
528 »       public·virtual·float·CalculateLightRadius(GameData.PlayerInfo·player)527 »       public·virtual·float·CalculateLightRadius(NetworkedPlayerInfo·player)
529 »       {528 »       {
530 »       »       if·(player·==·null·||·player.IsDead)529 »       »       if·(player·==·null·||·player.IsDead)
531 »       »       {530 »       »       {
532 »       »       »       return·this.MaxLightRadius;531 »       »       »       return·this.MaxLightRadius;
533 »       »       }532 »       »       }
534 »       »       if·(player.Role.IsImpostor)533 »       »       if·(player.Role.IsImpostor)
535 »       »       {534 »       »       {
Offset 540, 15 lines modifiedOffset 539, 15 lines modified
540 »       »       if·(this.Systems.TryGetValue(SystemTypes.Electrical,·out·systemType))539 »       »       if·(this.Systems.TryGetValue(SystemTypes.Electrical,·out·systemType))
541 »       »       {540 »       »       {
542 »       »       »       num·=·(float)(systemType·as·SwitchSystem).Value·/·255f;541 »       »       »       num·=·(float)(systemType·as·SwitchSystem).Value·/·255f;
543 »       »       }542 »       »       }
544 »       »       return·Mathf.Lerp(this.MinLightRadius,·this.MaxLightRadius,·num)·*·GameOptionsManager.Instance.CurrentGameOptions.GetFloat(FloatOptionNames.CrewLightMod);543 »       »       return·Mathf.Lerp(this.MinLightRadius,·this.MaxLightRadius,·num)·*·GameOptionsManager.Instance.CurrentGameOptions.GetFloat(FloatOptionNames.CrewLightMod);
545 »       }544 »       }
546 545
547 »       public·void·StartMeeting(PlayerControl·reporter,·GameData.PlayerInfo·target)546 »       public·void·StartMeeting(PlayerControl·reporter,·NetworkedPlayerInfo·target)
548 »       {547 »       {
549 »       »       base.StartCoroutine(this.CoStartMeeting(reporter,·target));548 »       »       base.StartCoroutine(this.CoStartMeeting(reporter,·target));
550 »       }549 »       }
551 550
552 »       public·PlayerTask·GetSabotageTask(SystemTypes·system)551 »       public·PlayerTask·GetSabotageTask(SystemTypes·system)
553 »       {552 »       {
554 »       »       TaskTypes·taskTypes;553 »       »       TaskTypes·taskTypes;
Offset 598, 23 lines modifiedOffset 597, 23 lines modified
598 »       »       }597 »       »       }
599 »       »       taskTypes·=·TaskTypes.None;598 »       »       taskTypes·=·TaskTypes.None;
600 »       »       IL_005B:599 »       »       IL_005B:
601 »       »       TaskTypes·taskTypeForSystem·=·taskTypes;600 »       »       TaskTypes·taskTypeForSystem·=·taskTypes;
602 »       »       return·Enumerable.First<PlayerTask>(this.SpecialTasks,·(PlayerTask·task)·=>·task.TaskType·==·taskTypeForSystem);601 »       »       return·Enumerable.First<PlayerTask>(this.SpecialTasks,·(PlayerTask·task)·=>·task.TaskType·==·taskTypeForSystem);
603 »       }602 »       }
604 603
605 »       public·IEnumerator·CoStartMeeting(PlayerControl·reporter,·GameData.PlayerInfo·target)604 »       public·IEnumerator·CoStartMeeting(PlayerControl·reporter,·NetworkedPlayerInfo·target)
606 »       {605 »       {
607 »       »       while·(!MeetingHud.Instance)606 »       »       while·(!MeetingHud.Instance)
608 »       »       {607 »       »       {
609 »       »       »       yield·return·null;608 »       »       »       yield·return·null;
610 »       »       }609 »       »       }
611 »       »       MeetingRoomManager.Instance.RemoveSelf();610 »       »       MeetingRoomManager.Instance.RemoveSelf();
612 »       »       DestroyableSingleton<HudManager>.Instance.InitMap();611 »       »       DestroyableSingleton<HudManager>.Instance.InitMap();
613 »       »       MapBehaviour.Instance.SetPreMeetingPosition(PlayerControl.LocalPlayer.transform.position);612 »       »       MapBehaviour.Instance.SetPreMeetingPosition(PlayerControl.LocalPlayer.transform.position,·false);
614 »       »       for·(int·i·=·0;·i·<·PlayerControl.AllPlayerControls.Count;·i++)613 »       »       for·(int·i·=·0;·i·<·PlayerControl.AllPlayerControls.Count;·i++)
615 »       »       {614 »       »       {
616 »       »       »       PlayerControl·playerControl·=·PlayerControl.AllPlayerControls[i];615 »       »       »       PlayerControl·playerControl·=·PlayerControl.AllPlayerControls[i];
617 »       »       »       if·(playerControl·!=·null)616 »       »       »       if·(playerControl·!=·null)
618 »       »       »       {617 »       »       »       {
619 »       »       »       »       playerControl.ResetForMeeting();618 »       »       »       »       playerControl.ResetForMeeting();
620 »       »       »       }619 »       »       »       }
Offset 626, 15 lines modifiedOffset 625, 15 lines modified
626 »       »       if·(Minigame.Instance)625 »       »       if·(Minigame.Instance)
627 »       »       {626 »       »       {
628 »       »       »       Minigame.Instance.ForceClose();627 »       »       »       Minigame.Instance.ForceClose();
629 »       »       }628 »       »       }
630 »       »       ShipStatus.Instance.OnMeetingCalled();629 »       »       ShipStatus.Instance.OnMeetingCalled();
631 »       »       KillAnimation.SetMovement(reporter,·true);630 »       »       KillAnimation.SetMovement(reporter,·true);
632 »       »       DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>();631 »       »       DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>();
633 »       »       GameData.PlayerInfo[]·array2·=·Enumerable.ToArray<GameData.PlayerInfo>(Enumerable.Select<DeadBody,·GameData.PlayerInfo>(array,·(DeadBody·b)·=>·GameData.Instance.GetPlayerById(b.ParentId)));632 »       »       NetworkedPlayerInfo[]·array2·=·Enumerable.ToArray<NetworkedPlayerInfo>(Enumerable.Select<DeadBody,·NetworkedPlayerInfo>(array,·(DeadBody·b)·=>·GameData.Instance.GetPlayerById(b.ParentId)));
634 »       »       for·(int·j·=·0;·j·<·array.Length;·j++)633 »       »       for·(int·j·=·0;·j·<·array.Length;·j++)
635 »       »       {634 »       »       {
636 »       »       »       if·(array[j]·!=·null·&&·array[j].gameObject·!=·null)635 »       »       »       if·(array[j]·!=·null·&&·array[j].gameObject·!=·null)
637 »       »       »       {636 »       »       »       {
638 »       »       »       »       Object.Destroy(array[j].gameObject);637 »       »       »       »       Object.Destroy(array[j].gameObject);
639 »       »       »       }638 »       »       »       }
640 »       »       »       else639 »       »       »       else
Offset 650, 15 lines modifiedOffset 649, 35 lines modified
650 »       »       »       »       Object.Destroy(array3[k].gameObject);649 »       »       »       »       Object.Destroy(array3[k].gameObject);
651 »       »       »       }650 »       »       »       }
652 »       »       »       else651 »       »       »       else
Max diff block lines reached; 1068/6229 bytes (17.15%) of diff not shown.
627 B
Assembly-CSharp/SignInStatusComponent.cs
    
Offset 40, 15 lines modifiedOffset 40, 18 lines modified
40 »       »       »       return;40 »       »       »       return;
41 »       »       }41 »       »       }
42 »       »       DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden·=·!DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden;42 »       »       DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden·=·!DestroyableSingleton<FriendsListManager>.Instance.FriendCodeHidden;
43 »       }43 »       }
44 44
45 »       private·void·Update()45 »       private·void·Update()
46 »       {46 »       {
 47 »       »       if·(DestroyableSingleton<EOSManager>.Instance.HasFinishedLoginFlow())
 48 »       »       {
47 »       »       this.UpdateFriendCodeUI();49 »       »       »       this.UpdateFriendCodeUI();
 50 »       »       }
48 »       }51 »       }
49 52
50 »       private·void·UpdateFriendCodeUI()53 »       private·void·UpdateFriendCodeUI()
51 »       {54 »       {
52 »       »       if·(!DestroyableSingleton<EOSManager>.Instance.IsFriendsListAllowed())55 »       »       if·(!DestroyableSingleton<EOSManager>.Instance.IsFriendsListAllowed())
53 »       »       {56 »       »       {
54 »       »       »       this.FriendCodeHiddenIcon.enabled·=·false;57 »       »       »       this.FriendCodeHiddenIcon.enabled·=·false;
1.99 KB
Assembly-CSharp/SkeldExileController.cs
    
Offset 6, 33 lines modifiedOffset 6, 43 lines modified
6 {6 {
7 »       protected·override·IEnumerator·Animate()7 »       protected·override·IEnumerator·Animate()
8 »       {8 »       {
9 »       »       float·num·=·Camera.main.orthographicSize·*·Camera.main.aspect·+·1f;9 »       »       float·num·=·Camera.main.orthographicSize·*·Camera.main.aspect·+·1f;
10 »       »       Vector2·left·=·Vector2.left·*·num;10 »       »       Vector2·left·=·Vector2.left·*·num;
11 »       »       Vector2·right·=·Vector2.right·*·num;11 »       »       Vector2·right·=·Vector2.right·*·num;
12 »       »       this.Player.transform.localPosition·=·left;12 »       »       this.Player.transform.localPosition·=·left;
 13 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 14 »       »       {
13 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);15 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.black,·Color.clear,·0.2f,·false);
 16 »       »       }
14 »       »       yield·return·new·WaitForSeconds(0.2f);17 »       »       yield·return·new·WaitForSeconds(0.2f);
15 »       »       if·(this.exiled·!=·null·&&·this.EjectSound)18 »       »       if·(this.initData·!=·null·&&·this.initData.outfit·!=·null·&&·this.EjectSound)
16 »       »       {19 »       »       {
17 »       »       »       SoundManager.Instance.PlayDynamicSound("PlayerEjected",·this.EjectSound,·true,·new·DynamicSound.GetDynamicsFunction(this.SoundDynamics),·SoundManager.Instance.SfxChannel);20 »       »       »       SoundManager.Instance.PlayDynamicSound("PlayerEjected",·this.EjectSound,·true,·new·DynamicSound.GetDynamicsFunction(this.SoundDynamics),·SoundManager.Instance.SfxChannel);
18 »       »       }21 »       »       }
19 »       »       yield·return·new·WaitForSeconds(0.8f);22 »       »       yield·return·new·WaitForSeconds(0.8f);
20 »       »       yield·return·Effects.All(new·IEnumerator[]23 »       »       yield·return·Effects.All(new·IEnumerator[]
21 »       »       {24 »       »       {
22 »       »       »       this.PlayerSpin(left,·right),25 »       »       »       this.PlayerSpin(left,·right),
23 »       »       »       this.HandleText(this.Duration·*·0.3f,·this.Duration·*·0.5f)26 »       »       »       this.HandleText(this.Duration·*·0.3f,·this.Duration·*·0.5f)
24 »       »       });27 »       »       });
25 »       »       if·(GameManager.Instance.LogicOptions.GetConfirmImpostor())28 »       »       if·(this.initData.confirmImpostor)
26 »       »       {29 »       »       {
27 »       »       »       this.ImpostorText.gameObject.SetActive(true);30 »       »       »       this.ImpostorText.gameObject.SetActive(true);
28 »       »       }31 »       »       }
29 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);32 »       »       yield·return·Effects.Bloop(0f,·this.ImpostorText.transform,·1f,·0.5f);
30 »       »       yield·return·new·WaitForSeconds(0.5f);33 »       »       yield·return·new·WaitForSeconds(0.5f);
 34 »       »       if·(DestroyableSingleton<HudManager>.InstanceExists)
 35 »       »       {
31 »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);36 »       »       »       yield·return·DestroyableSingleton<HudManager>.Instance.CoFadeFullScreen(Color.clear,·Color.black,·0.2f,·false);
 37 »       »       }
 38 »       »       else
 39 »       »       {
 40 »       »       »       yield·return·Effects.Wait(0.2f);
 41 »       »       }
32 »       »       base.WrapUp();42 »       »       base.WrapUp();
33 »       »       yield·break;43 »       »       yield·break;
34 »       }44 »       }
35 45
36 »       private·IEnumerator·PlayerSpin(Vector2·left,·Vector2·right)46 »       private·IEnumerator·PlayerSpin(Vector2·left,·Vector2·right)
37 »       {47 »       {
38 »       »       for·(float·t·=·0f;·t·<=·this.Duration;·t·+=·Time.deltaTime)48 »       »       for·(float·t·=·0f;·t·<=·this.Duration;·t·+=·Time.deltaTime)
686 B
Assembly-CSharp/SkinLayer.cs
    
Offset 242, 15 lines modifiedOffset 242, 15 lines modified
242 »       {242 »       {
243 »       »       this.matProperties.ColorId·=·color;243 »       »       this.matProperties.ColorId·=·color;
244 »       »       this.UpdateMaterial();244 »       »       this.UpdateMaterial();
245 »       }245 »       }
246 246
247 »       public·bool·IsPlayingRunAnim()247 »       public·bool·IsPlayingRunAnim()
248 »       {248 »       {
249 »       »       return·this.animator.GetCurrentAnimation()·==·this.skin.RunAnim·||·this.animator.GetCurrentAnimation()·==·this.skin.RunLeftAnim;249 »       »       return·!(this.animator·==·null)·&&·!(this.skin·==·null)·&&·(this.animator.GetCurrentAnimation()·==·this.skin.RunAnim·||·this.animator.GetCurrentAnimation()·==·this.skin.RunLeftAnim);
250 »       }250 »       }
251 251
252 »       private·void·UpdateMaterial()252 »       private·void·UpdateMaterial()
253 »       {253 »       {
254 »       »       PlayerMaterial.MaskType·maskType·=·this.matProperties.MaskType;254 »       »       PlayerMaterial.MaskType·maskType·=·this.matProperties.MaskType;
255 »       »       if·(this.skin·&&·this.skin.MatchPlayerColor)255 »       »       if·(this.skin·&&·this.skin.MatchPlayerColor)
256 »       »       {256 »       »       {
321 B
Assembly-CSharp/SkinViewData.cs
    
Offset 58, 8 lines modifiedOffset 58, 12 lines modified
58 »       public·AnimationClip·KillStabImpostor;58 »       public·AnimationClip·KillStabImpostor;
59 59
60 »       public·AnimationClip·KillStabVictim;60 »       public·AnimationClip·KillStabVictim;
61 61
62 »       public·AnimationClip·KillRHMVictim;62 »       public·AnimationClip·KillRHMVictim;
63 63
64 »       public·int·CustomKillAnimID;64 »       public·int·CustomKillAnimID;
 65
 66 »       public·string·VisorID_KillAnim;
 67
 68 »       public·string·HatID_KillAnim;
65 }69 }
422 B
Assembly-CSharp/SortableSample.cs
Ordering differences only
    
Offset 84, 16 lines modifiedOffset 84, 16 lines modified
84 84
85 »       [SerializeField]85 »       [SerializeField]
86 »       private·bool·isMushroom;86 »       private·bool·isMushroom;
87 87
88 »       [SerializeField]88 »       [SerializeField]
89 »       private·float·distanceAboveJar;89 »       private·float·distanceAboveJar;
90 90
91 »       [Header("Audio")] 
92 »       [SerializeField]91 »       [SerializeField]
 92 »       [Header("Audio")]
93 »       private·AudioClip·pickUpSfx;93 »       private·AudioClip·pickUpSfx;
94 94
95 »       [SerializeField]95 »       [SerializeField]
96 »       private·AudioClip·placeCorrectSfx;96 »       private·AudioClip·placeCorrectSfx;
97 97
98 »       private·Vector3·originalPosition;98 »       private·Vector3·originalPosition;
99 }99 }
925 B
Assembly-CSharp/SoundManager.cs
    
Offset 349, 20 lines modifiedOffset 349, 20 lines modified
349 »       »       »       audioSource.clip·=·clip;349 »       »       »       audioSource.clip·=·clip;
350 »       »       »       audioSource.Play();350 »       »       »       audioSource.Play();
351 »       »       »       this.allSources.Add(clip,·audioSource);351 »       »       »       this.allSources.Add(clip,·audioSource);
352 »       »       }352 »       »       }
353 »       »       return·audioSource;353 »       »       return·audioSource;
354 »       }354 »       }
355 355
356 »       public·static·float·GetSoundVolume(Vector2·soundPosition,·Vector2·listenerPosition,·float·falloffStartDistance·=·2f,·float·falloffEndDistance·=·6f)356 »       public·static·float·GetSoundVolume(Vector2·soundPosition,·Vector2·listenerPosition,·float·falloffStartDistance·=·2f,·float·falloffEndDistance·=·6f,·float·minVolume·=·0f)
357 »       {357 »       {
358 »       »       float·num·=·Vector2.Distance(listenerPosition,·soundPosition);358 »       »       float·num·=·Vector2.Distance(listenerPosition,·soundPosition);
359 »       »       if·(num·>·falloffEndDistance)359 »       »       if·(num·>·falloffEndDistance)
360 »       »       {360 »       »       {
361 »       »       »       return·0f;361 »       »       »       return·minVolume;
362 »       »       }362 »       »       }
363 »       »       if·(num·>=·falloffStartDistance)363 »       »       if·(num·>=·falloffStartDistance)
364 »       »       {364 »       »       {
365 »       »       »       float·num2·=·(num·-·falloffStartDistance)·/·(falloffEndDistance·-·falloffStartDistance);365 »       »       »       float·num2·=·(num·-·falloffStartDistance)·/·(falloffEndDistance·-·falloffStartDistance);
366 »       »       »       return·1f·-·Mathf.Clamp01(Mathf.SmoothStep(0f,·1f,·num2));366 »       »       »       return·1f·-·Mathf.Clamp01(Mathf.SmoothStep(0f,·1f,·num2));
367 »       »       }367 »       »       }
368 »       »       return·1f;368 »       »       return·1f;
1.35 KB
Assembly-CSharp/SpawnInMinigame.cs
    
Offset 28, 20 lines modifiedOffset 28, 20 lines modified
28 »       »       »       ButtonAnimRolloverHandler·component·=·passiveButton.GetComponent<ButtonAnimRolloverHandler>();28 »       »       »       ButtonAnimRolloverHandler·component·=·passiveButton.GetComponent<ButtonAnimRolloverHandler>();
29 »       »       »       component.StaticOutImage·=·pt.Image;29 »       »       »       component.StaticOutImage·=·pt.Image;
30 »       »       »       component.RolloverAnim·=·pt.Rollover;30 »       »       »       component.RolloverAnim·=·pt.Rollover;
31 »       »       »       component.HoverSound·=·(pt.RolloverSfx·?·pt.RolloverSfx·:·this.DefaultRolloverSound);31 »       »       »       component.HoverSound·=·(pt.RolloverSfx·?·pt.RolloverSfx·:·this.DefaultRolloverSound);
32 »       »       }32 »       »       }
33 »       »       if·(GameManager.Instance·!=·null·&&·GameManager.Instance.IsNormal())33 »       »       if·(GameManager.Instance·!=·null·&&·GameManager.Instance.IsNormal())
34 »       »       {34 »       »       {
35 »       »       »       foreach·(GameData.PlayerInfo·playerInfo·in·GameData.Instance.AllPlayers)35 »       »       »       foreach·(NetworkedPlayerInfo·networkedPlayerInfo·in·GameData.Instance.AllPlayers)
36 »       »       »       {36 »       »       »       {
37 »       »       »       »       if·(playerInfo·!=·null·&&·!(playerInfo.Object·==·null)·&&·!playerInfo.Disconnected)37 »       »       »       »       if·(!(networkedPlayerInfo·==·null)·&&·!(networkedPlayerInfo.Object·==·null)·&&·!networkedPlayerInfo.Disconnected)
38 »       »       »       »       {38 »       »       »       »       {
39 »       »       »       »       »       playerInfo.Object.NetTransform.transform.position·=·new·Vector2(-25f,·40f);39 »       »       »       »       »       networkedPlayerInfo.Object.NetTransform.transform.position·=·new·Vector2(-25f,·40f);
40 »       »       »       »       »       playerInfo.Object.NetTransform.Halt();40 »       »       »       »       »       networkedPlayerInfo.Object.NetTransform.Halt();
41 »       »       »       »       }41 »       »       »       »       }
42 »       »       »       }42 »       »       »       }
43 »       »       }43 »       »       }
44 »       »       base.StartCoroutine(this.RunTimer());44 »       »       base.StartCoroutine(this.RunTimer());
45 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·null,·this.DefaultButtonSelected,·this.ControllerSelectable,·false);45 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·null,·this.DefaultButtonSelected,·this.ControllerSelectable,·false);
46 »       »       PlayerControl.HideCursorTemporarily();46 »       »       PlayerControl.HideCursorTemporarily();
47 »       »       ConsoleJoystick.SetMode_Menu();47 »       »       ConsoleJoystick.SetMode_Menu();
488 B
Assembly-CSharp/StarGen.cs
Ordering differences only
    
Offset 1, 12 lines modifiedOffset 1, 12 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 [RequireComponent(typeof(MeshRenderer))] 
5 [RequireComponent(typeof(MeshFilter))]4 [RequireComponent(typeof(MeshFilter))]
 5 [RequireComponent(typeof(MeshRenderer))]
6 public·class·StarGen·:·MonoBehaviour6 public·class·StarGen·:·MonoBehaviour
7 {7 {
8 »       public·void·Start()8 »       public·void·Start()
9 »       {9 »       {
10 »       »       this.stars·=·new·StarGen.Stars[this.NumStars];10 »       »       this.stars·=·new·StarGen.Stars[this.NumStars];
11 »       »       this.verts·=·new·Vector3[this.NumStars·*·4];11 »       »       this.verts·=·new·Vector3[this.NumStars·*·4];
12 »       »       Vector2[]·array·=·new·Vector2[this.NumStars·*·4];12 »       »       Vector2[]·array·=·new·Vector2[this.NumStars·*·4];
7.6 KB
Assembly-CSharp/StatsPopup.cs
    
Offset 11, 76 lines modifiedOffset 11, 86 lines modified
11 »       private·void·OnDisable()11 »       private·void·OnDisable()
12 »       {12 »       {
13 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);13 »       »       ControllerManager.Instance.CloseOverlayMenu(base.name);
14 »       }14 »       }
15 15
16 »       private·void·OnEnable()16 »       private·void·OnEnable()
17 »       {17 »       {
 18 »       »       this.DisplayGameStats();
 19 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton,·this.SelectableButtons[0],·Enumerable.ToList<UiElement>(Enumerable.Select<UiElement,·UiElement>(Enumerable.Where<UiElement>(this.SelectableButtons,·(UiElement·x)·=>·x.gameObject.activeSelf),·(UiElement·x)·=>·x)),·false);
 20 »       }
 21
 22 »       private·static·object·GetFloatStatStr(float·stat)
 23 »       {
 24 »       »       if·(float.IsNaN(stat))
 25 »       »       {
 26 »       »       »       return·"---";
 27 »       »       }
 28 »       »       return·Mathf.Round(stat·*·1000f)·*·0.001f;
 29 »       }
 30
 31 »       private·static·void·AppendStat(StringBuilder·str,·StringNames·statName,·object·stat,·params·object[]·additionalTranslationParams)
 32 »       {
 33 »       »       str.Append("<align=left>"·+·DestroyableSingleton<TranslationController>.Instance.GetString(statName,·additionalTranslationParams).Trim()·+·"<line-height=0>");
 34 »       »       str.AppendLine();
 35 »       »       str.Append("<align=right>"·+·((stat·!=·null)·?·stat.ToString()·:·null)·+·"<line-height=1em>");
 36 »       »       str.AppendLine();
 37 »       }
 38
 39 »       public·void·DisplayGameStats()
 40 »       {
18 »       »       StringBuilder·stringBuilder·=·new·StringBuilder(1024);41 »       »       StringBuilder·stringBuilder·=·new·StringBuilder(1024);
19 »       »       StringBuilder·stringBuilder2·=·new·StringBuilder(256); 
20 »       »       foreach·(StringNames·stringNames·in·StatsPopup.BaseStatsToShow)42 »       »       foreach·(StringNames·stringNames·in·StatsPopup.BaseStatsToShow)
21 »       »       {43 »       »       {
22 »       »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·stringNames,·StatsManager.Instance.GetStat(stringNames),·Array.Empty<object>());44 »       »       »       StatsPopup.AppendStat(stringBuilder,·stringNames,·StatsManager.Instance.GetStat(stringNames),·Array.Empty<object>());
23 »       »       }45 »       »       }
24 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsFastestCrewmateWin_HideAndSeek,·StatsPopup.GetFloatStatStr(StatsManager.Instance.GetFastestHideAndSeekCrewmateWin()),·Array.Empty<object>());46 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsFastestCrewmateWin_HideAndSeek,·StatsPopup.GetFloatStatStr(StatsManager.Instance.GetFastestHideAndSeekCrewmateWin()),·Array.Empty<object>());
25 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsFastestImpostorWin_HideAndSeek,·StatsPopup.GetFloatStatStr(StatsManager.Instance.GetFastestHideAndSeekImpostorWin()),·Array.Empty<object>());47 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsFastestImpostorWin_HideAndSeek,·StatsPopup.GetFloatStatStr(StatsManager.Instance.GetFastestHideAndSeekImpostorWin()),·Array.Empty<object>());
26 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsImpostorVoteWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorByVote),·Array.Empty<object>());48 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsImpostorVoteWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorByVote),·Array.Empty<object>());
27 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsImpostorKillsWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorByKill),·Array.Empty<object>());49 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsImpostorKillsWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorByKill),·Array.Empty<object>());
28 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsImpostorSabotageWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorBySabotage),·Array.Empty<object>());50 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsImpostorSabotageWins,·StatsManager.Instance.GetWinReason(GameOverReason.ImpostorBySabotage),·Array.Empty<object>());
29 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsCrewmateVoteWins,·StatsManager.Instance.GetWinReason(GameOverReason.HumansByVote),·Array.Empty<object>());51 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsCrewmateVoteWins,·StatsManager.Instance.GetWinReason(GameOverReason.HumansByVote),·Array.Empty<object>());
30 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsCrewmateTaskWins,·StatsManager.Instance.GetWinReason(GameOverReason.HumansByTask),·Array.Empty<object>());52 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsCrewmateTaskWins,·StatsManager.Instance.GetWinReason(GameOverReason.HumansByTask),·Array.Empty<object>());
31 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsHideAndSeekCrewmateVictory,·StatsManager.Instance.GetWinReason(GameOverReason.HideAndSeek_ByTimer),·Array.Empty<object>());53 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsHideAndSeekCrewmateVictory,·StatsManager.Instance.GetWinReason(GameOverReason.HideAndSeek_ByTimer),·Array.Empty<object>());
32 »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·StringNames.StatsHideAndSeekImpostorVictory,·StatsManager.Instance.GetWinReason(GameOverReason.HideAndSeek_ByKills),·Array.Empty<object>());54 »       »       StatsPopup.AppendStat(stringBuilder,·StringNames.StatsHideAndSeekImpostorVictory,·StatsManager.Instance.GetWinReason(GameOverReason.HideAndSeek_ByKills),·Array.Empty<object>());
 55 »       »       this.StatsText.text·=·stringBuilder.ToString();
 56 »       }
 57
 58 »       public·void·DisplayRoleStats()
 59 »       {
 60 »       »       StringBuilder·stringBuilder·=·new·StringBuilder(1024);
33 »       »       foreach·(RoleTypes·roleTypes·in·Enumerable.ToArray<RoleTypes>(Enumerable.Cast<RoleTypes>(Enum.GetValues(typeof(RoleTypes)))))61 »       »       foreach·(RoleTypes·roleTypes·in·Enumerable.ToArray<RoleTypes>(Enumerable.Cast<RoleTypes>(Enum.GetValues(typeof(RoleTypes)))))
34 »       »       {62 »       »       {
35 »       »       »       if·(roleTypes·!=·RoleTypes.ImpostorGhost·&&·roleTypes·!=·RoleTypes.CrewmateGhost)63 »       »       »       if·(roleTypes·!=·RoleTypes.ImpostorGhost·&&·roleTypes·!=·RoleTypes.CrewmateGhost)
36 »       »       »       {64 »       »       »       {
37 »       »       »       »       StringBuilder·stringBuilder3·=·stringBuilder;65 »       »       »       »       StringBuilder·stringBuilder2·=·stringBuilder;
38 »       »       »       »       StringBuilder·stringBuilder4·=·stringBuilder2; 
39 »       »       »       »       StringNames·stringNames2·=·StringNames.StatsRoleWins;66 »       »       »       »       StringNames·stringNames·=·StringNames.StatsRoleWins;
40 »       »       »       »       object·obj·=·StatsManager.Instance.GetRoleWinCount(roleTypes);67 »       »       »       »       object·obj·=·StatsManager.Instance.GetRoleWinCount(roleTypes);
41 »       »       »       »       object[]·array2·=·new·object[1];68 »       »       »       »       object[]·array2·=·new·object[1];
42 »       »       »       »       int·num·=·0;69 »       »       »       »       int·num·=·0;
43 »       »       »       »       RoleBehaviour·role·=·DestroyableSingleton<RoleManager>.Instance.GetRole(roleTypes);70 »       »       »       »       RoleBehaviour·role·=·DestroyableSingleton<RoleManager>.Instance.GetRole(roleTypes);
44 »       »       »       »       array2[num]·=·((role·!=·null)·?·role.NiceName·:·null)·??·roleTypes;71 »       »       »       »       array2[num]·=·((role·!=·null)·?·role.NiceName·:·null)·??·roleTypes;
45 »       »       »       »       StatsPopup.AppendStat(stringBuilder3,·stringBuilder4,·stringNames2,·obj,·array2);72 »       »       »       »       StatsPopup.AppendStat(stringBuilder2,·stringNames,·obj,·array2);
46 »       »       »       }73 »       »       »       }
47 »       »       }74 »       »       }
48 »       »       foreach·(StringNames·stringNames3·in·StatsPopup.RoleSpecificStatsToShow)75 »       »       foreach·(StringNames·stringNames2·in·StatsPopup.RoleSpecificStatsToShow)
49 »       »       {76 »       »       {
50 »       »       »       StatsPopup.AppendStat(stringBuilder,·stringBuilder2,·stringNames3,·StatsManager.Instance.GetStat(stringNames3),·Array.Empty<object>());77 »       »       »       StatsPopup.AppendStat(stringBuilder,·stringNames2,·StatsManager.Instance.GetStat(stringNames2),·Array.Empty<object>());
51 »       »       }78 »       »       }
52 »       »       this.StatsText.text·=·stringBuilder.ToString();79 »       »       this.StatsText.text·=·stringBuilder.ToString();
53 »       »       this.NumbersText.text·=·stringBuilder2.ToString(); 
54 »       »       ControllerManager.Instance.OpenOverlayMenu(base.name,·this.BackButton); 
55 »       } 
56  
57 »       private·static·object·GetFloatStatStr(float·stat) 
58 »       { 
59 »       »       if·(float.IsNaN(stat)) 
60 »       »       { 
61 »       »       »       return·"---"; 
62 »       »       } 
63 »       »       return·Mathf.Round(stat·*·1000f)·*·0.001f; 
64 »       } 
65  
66 »       private·static·void·AppendStat(StringBuilder·str,·StringBuilder·strNums,·StringNames·statName,·object·stat,·params·object[]·additionalTranslationParams) 
67 »       { 
68 »       »       str.AppendLine(DestroyableSingleton<TranslationController>.Instance.GetString(statName,·additionalTranslationParams)); 
69 »       »       strNums.Append(stat); 
70 »       »       strNums.AppendLine(); 
71 »       }80 »       }
72 81
73 »       public·TextMeshPro·StatsText;82 »       public·TextMeshPro·StatsText;
74 83
75 »       public·TextMeshPro·NumbersText; 
76  
77 »       [Header("Console·Controller·Navigation")]84 »       [Header("Console·Controller·Navigation")]
78 »       public·UiElement·BackButton;85 »       public·UiElement·BackButton;
79 86
 87 »       [SerializeField]
 88 »       private·UiElement[]·SelectableButtons;
 89
80 »       private·static·readonly·List<StringNames>·BaseStatsToShow·=·new·List<StringNames>90 »       private·static·readonly·List<StringNames>·BaseStatsToShow·=·new·List<StringNames>
81 »       {91 »       {
82 »       »       StringNames.StatsBodiesReported,92 »       »       StringNames.StatsBodiesReported,
83 »       »       StringNames.StatsEmergenciesCalled,93 »       »       StringNames.StatsEmergenciesCalled,
84 »       »       StringNames.StatsTasksCompleted,94 »       »       StringNames.StatsTasksCompleted,
85 »       »       StringNames.StatsAllTasksCompleted,95 »       »       StringNames.StatsAllTasksCompleted,
86 »       »       StringNames.StatsSabotagesFixed,96 »       »       StringNames.StatsSabotagesFixed,
1.79 KB
Assembly-CSharp/StoreManager.cs
    
Offset 51, 36 lines modifiedOffset 51, 41 lines modified
51 »       »       this.logger.Warning("Failed·to·init·store·message:\r\n"·+·error.ToString()·+·"·message:·"·+·message,·null);51 »       »       this.logger.Warning("Failed·to·init·store·message:\r\n"·+·error.ToString()·+·"·message:·"·+·message,·null);
52 »       }52 »       }
53 53
54 »       public·void·ProcessOldReceiptsRestore()54 »       public·void·ProcessOldReceiptsRestore()
55 »       {55 »       {
56 »       »       if·(!this.initialized)56 »       »       if·(!this.initialized)
57 »       »       {57 »       »       {
 58 »       »       »       Debug.Log("UpdateInventory·::·store·manager·not·initialized");
58 »       »       »       this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null);59 »       »       »       this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null);
59 »       »       »       DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail);60 »       »       »       DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail);
60 »       »       »       return;61 »       »       »       return;
61 »       »       }62 »       »       }
62 »       »       if·(this.extensions·==·null)63 »       »       if·(this.extensions·==·null)
63 »       »       {64 »       »       {
 65 »       »       »       Debug.Log("UpdateInventory·::·extensions·not·initialized");
64 »       »       »       this.logger.Error("Somehow·StoreManager·was·initialized,·but·no·IExtensionProvider·(this.extensions)·was·set.",·null);66 »       »       »       this.logger.Error("Somehow·StoreManager·was·initialized,·but·no·IExtensionProvider·(this.extensions)·was·set.",·null);
65 »       »       »       DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail);67 »       »       »       DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail);
66 »       »       »       return;68 »       »       »       return;
67 »       »       }69 »       »       }
68 »       »       this.ProcessOldReceipts();70 »       »       this.ProcessOldReceipts();
69 »       }71 »       }
70 72
71 »       public·void·ProcessOldReceipts()73 »       public·void·ProcessOldReceipts()
72 »       {74 »       {
 75 »       »       Debug.Log("UpdateInventory·::·start·process·old·receipts");
73 »       »       if·(!this.initialized)76 »       »       if·(!this.initialized)
74 »       »       {77 »       »       {
 78 »       »       »       Debug.Log("UpdateInventory·::·tried·to·process·old·receipts·before·the·store·was·finished·initializing");
75 »       »       »       this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null);79 »       »       »       this.logger.Warning("Tried·to·process·old·receipts·before·store·was·finished·initializing",·null);
76 »       »       »       DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail);80 »       »       »       DestroyableSingleton<EOSManager>.Instance.validateOldDLC.MarkComplete(PurchaseStates.Fail);
77 »       »       »       return;81 »       »       »       return;
78 »       »       }82 »       »       }
79 »       »       List<string>·list·=·new·List<string>();83 »       »       List<string>·list·=·new·List<string>();
 84 »       »       Debug.Log("UpdateInventory·::·all·products·count·"·+·this.allProducts.Length.ToString());
80 »       »       foreach·(Product·product·in·this.allProducts)85 »       »       foreach·(Product·product·in·this.allProducts)
81 »       »       {86 »       »       {
82 »       »       »       if·(product·!=·null·&&·product.definition.type·==·ProductType.NonConsumable)87 »       »       »       if·(product·!=·null·&&·product.definition.type·==·ProductType.NonConsumable)
83 »       »       »       {88 »       »       »       {
84 »       »       »       »       Debug.Log(string.Format("receipts:·{0}:{1}·-·{2}·-·{3}·-·{4}·-·{5}·-·{6}",·new·object[]89 »       »       »       »       Debug.Log(string.Format("receipts:·{0}:{1}·-·{2}·-·{3}·-·{4}·-·{5}·-·{6}",·new·object[]
85 »       »       »       »       {90 »       »       »       »       {
86 »       »       »       »       »       product.hasReceipt,91 »       »       »       »       »       product.hasReceipt,
796 B
Assembly-CSharp/StoreMannequin.cs
    
Offset 41, 22 lines modifiedOffset 41, 22 lines modified
41 »       »       PetData·petData·=·product·as·PetData;41 »       »       PetData·petData·=·product·as·PetData;
42 »       »       if·(petData·!=·null)42 »       »       if·(petData·!=·null)
43 »       »       {43 »       »       {
44 »       »       »       this.hat.gameObject.SetActive(false);44 »       »       »       this.hat.gameObject.SetActive(false);
45 »       »       »       this.visor.gameObject.SetActive(false);45 »       »       »       this.visor.gameObject.SetActive(false);
46 »       »       »       this.skin.gameObject.SetActive(false);46 »       »       »       this.skin.gameObject.SetActive(false);
47 »       »       »       this.pet.gameObject.SetActive(true);47 »       »       »       this.pet.gameObject.SetActive(true);
48 »       »       »       this.pet.sprite·=·petData.SpritePreview;48 »       »       »       petData.SetPreview(this.pet,·num);
49 »       »       »       this.pet.material·=·new·Material(petData.PreviewCrewmateColor·?·this.playerMaterial·:·this.defaultMaterial);49 »       »       »       this.pet.material·=·new·Material(petData.PreviewCrewmateColor·?·this.playerMaterial·:·this.defaultMaterial);
50 »       »       »       PlayerMaterial.SetColors(num,·this.pet);50 »       »       »       PlayerMaterial.SetColors(num,·this.pet);
51 »       »       }51 »       »       }
52 »       }52 »       }
53 53
54 »       [SerializeField] 
55 »       [Header("Cosmetic·Slots")]54 »       [Header("Cosmetic·Slots")]
 55 »       [SerializeField]
56 »       private·HatParent·hat;56 »       private·HatParent·hat;
57 57
58 »       [SerializeField]58 »       [SerializeField]
59 »       private·VisorLayer·visor;59 »       private·VisorLayer·visor;
60 60
61 »       [SerializeField]61 »       [SerializeField]
62 »       private·SpriteRenderer·skin;62 »       private·SpriteRenderer·skin;
13.8 KB
Assembly-CSharp/StoreMenu.cs
    
Offset 11, 19 lines modifiedOffset 11, 14 lines modified
11 public·class·StoreMenu·:·DestroyableSingleton<StoreMenu>11 public·class·StoreMenu·:·DestroyableSingleton<StoreMenu>
12 {12 {
13 »       public·void·CloseConfirm()13 »       public·void·CloseConfirm()
14 »       {14 »       {
15 »       »       this.confirmMenu.SetActive(false);15 »       »       this.confirmMenu.SetActive(false);
16 »       »       this.starConfirmMenu.SetActive(false);16 »       »       this.starConfirmMenu.SetActive(false);
17 »       »       this.cosmicubePreviewMenu.gameObject.SetActive(false);17 »       »       this.cosmicubePreviewMenu.gameObject.SetActive(false);
18 »       »       if·(this.selectedTab·==·StoreTab.Bundles) 
19 »       »       { 
20 »       »       »       this.featuredMenu.SetActive(true); 
21 »       »       »       return; 
22 »       »       } 
23 »       »       this.normalMenu.SetActive(true);18 »       »       this.normalMenu.SetActive(true);
24 »       }19 »       }
25 20
26 »       public·void·CloseWaitModal()21 »       public·void·CloseWaitModal()
27 »       {22 »       {
28 »       »       this.plsWaitModal.gameObject.SetActive(false);23 »       »       this.plsWaitModal.gameObject.SetActive(false);
29 »       }24 »       }
Offset 520, 20 lines modifiedOffset 515, 20 lines modified
520 »       »       this.allHats·=·this.GetSortedStoreCosmetics<HatData>(DestroyableSingleton<HatManager>.Instance.AllHats);515 »       »       this.allHats·=·this.GetSortedStoreCosmetics<HatData>(DestroyableSingleton<HatManager>.Instance.AllHats);
521 »       »       this.allSkins·=·this.GetSortedStoreCosmetics<SkinData>(DestroyableSingleton<HatManager>.Instance.AllSkins);516 »       »       this.allSkins·=·this.GetSortedStoreCosmetics<SkinData>(DestroyableSingleton<HatManager>.Instance.AllSkins);
522 »       »       this.allVisors·=·this.GetSortedStoreCosmetics<VisorData>(DestroyableSingleton<HatManager>.Instance.AllVisors);517 »       »       this.allVisors·=·this.GetSortedStoreCosmetics<VisorData>(DestroyableSingleton<HatManager>.Instance.AllVisors);
523 »       »       this.allPlates·=·this.GetSortedStoreCosmetics<NamePlateData>(DestroyableSingleton<HatManager>.Instance.AllNamePlates);518 »       »       this.allPlates·=·this.GetSortedStoreCosmetics<NamePlateData>(DestroyableSingleton<HatManager>.Instance.AllNamePlates);
524 »       »       this.allPets·=·this.GetSortedStoreCosmetics<PetData>(DestroyableSingleton<HatManager>.Instance.AllPets);519 »       »       this.allPets·=·this.GetSortedStoreCosmetics<PetData>(DestroyableSingleton<HatManager>.Instance.AllPets);
525 »       »       this.allCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.ThenByDescending<CosmicubeData,·DateTime>(Enumerable.OrderBy<CosmicubeData,·bool>(DestroyableSingleton<CosmicubeManager>.Instance.GetAvailableCubeData(),·(CosmicubeData·p)·=>·DataManager.Player.Purchases.GetPurchase(p.ProdId,·"")),·(CosmicubeData·p)·=>·p.GetDateCreated()));520 »       »       this.allCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.ThenByDescending<CosmicubeData,·DateTime>(Enumerable.OrderBy<CosmicubeData,·bool>(DestroyableSingleton<CosmicubeManager>.Instance.GetAvailableCubeData(),·(CosmicubeData·p)·=>·DataManager.Player.Purchases.GetPurchase(p.ProdId,·"")),·(CosmicubeData·p)·=>·p.GetDateCreated()));
526 »       »       this.allStars·=·Enumerable.ToArray<StarBundle>(Enumerable.OrderBy<StarBundle,·float>(DestroyableSingleton<HatManager>.Instance.AllStarBundles,·(StarBundle·p)·=>·p.price));521 »       »       this.allStars·=·Enumerable.ToArray<StarBundle>(Enumerable.OrderBy<StarBundle,·float>(DestroyableSingleton<HatManager>.Instance.AllStarBundles,·(StarBundle·p)·=>·p.price));
527 »       »       this.allBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllBundles,·(BundleData·h)·=>·!h.Free·&&·!h.NotInStore));522 »       »       this.allBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllBundles,·(BundleData·h)·=>·!h.Free·&&·!h.NotInStore·&&·h.LimitedTimeAvailable.IsAvailable()));
528 »       »       DestroyableSingleton<HatManager>.Instance.RefreshFeatured();523 »       »       DestroyableSingleton<HatManager>.Instance.RefreshFeatured();
529 »       »       this.allFeaturedItems·=·Enumerable.ToArray<CosmeticData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedItems);524 »       »       this.allFeaturedItems·=·Enumerable.ToArray<CosmeticData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedItems);
530 »       »       this.allFeaturedCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.Where<CosmicubeData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedCubes,·(CosmicubeData·x)·=>·x.LimitedTimeAvailable.IsAvailable()));525 »       »       this.allFeaturedCubes·=·Enumerable.ToArray<CosmicubeData>(Enumerable.Where<CosmicubeData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedCubes,·(CosmicubeData·x)·=>·x.LimitedTimeAvailable.IsAvailable()));
531 »       »       this.allFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.BundleSize·==·BundleSizes.Wide));526 »       »       this.allFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.LimitedTimeAvailable.IsAvailable()·&&·x.BundleSize·==·BundleSizes.Wide));
532 »       »       this.allLargeFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.BundleSize·==·BundleSizes.Large));527 »       »       this.allLargeFeaturedBundles·=·Enumerable.ToArray<BundleData>(Enumerable.Where<BundleData>(DestroyableSingleton<HatManager>.Instance.AllFeaturedBundles,·(BundleData·x)·=>·x.LimitedTimeAvailable.IsAvailable()·&&·x.BundleSize·==·BundleSizes.Large));
533 »       }528 »       }
534 529
535 »       private·void·SetRefreshTimers()530 »       private·void·SetRefreshTimers()
536 »       {531 »       {
537 »       »       Dictionary<DateTime,·List<StoreTab>>·dictionary·=·new·Dictionary<DateTime,·List<StoreTab>>();532 »       »       Dictionary<DateTime,·List<StoreTab>>·dictionary·=·new·Dictionary<DateTime,·List<StoreTab>>();
538 »       »       this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllHats,·new·StoreTab[]·{·StoreTab.Hats·});533 »       »       this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllHats,·new·StoreTab[]·{·StoreTab.Hats·});
539 »       »       this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllSkins,·new·StoreTab[]·{·StoreTab.Skins·});534 »       »       this.AddRefreshTimers(dictionary,·DestroyableSingleton<HatManager>.Instance.AllSkins,·new·StoreTab[]·{·StoreTab.Skins·});
Offset 765, 136 lines modifiedOffset 760, 121 lines modified
765 »       »       »       »       Vector3·vector2·=·vector;760 »       »       »       »       Vector3·vector2·=·vector;
766 »       »       »       »       IBuyable[]·array·=·this.allCubes;761 »       »       »       »       IBuyable[]·array·=·this.allCubes;
767 »       »       »       »       vector·=·this.AddProductFromList(vector2,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.CubesRange,·1f,·false);762 »       »       »       »       vector·=·this.AddProductFromList(vector2,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.CubesRange,·1f,·false);
768 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Cosmicubes,·Array.Empty<object>());763 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Cosmicubes,·Array.Empty<object>());
769 »       »       »       »       break;764 »       »       »       »       break;
770 »       »       »       }765 »       »       »       }
771 »       »       »       case·StoreTab.Bundles:766 »       »       »       case·StoreTab.Bundles:
772 »       »       »       »       foreach·(BundlePurchaseButton·bundlePurchaseButton·in·Enumerable.ToList<BundlePurchaseButton>(this.featuredMenu.GetComponentsInChildren<BundlePurchaseButton>(true)))767 »       »       »       {
 768 »       »       »       »       vector.y·+=·-0.975f;
 769 »       »       »       »       Vector3·vector3·=·vector;
 770 »       »       »       »       IBuyable[]·array·=·this.allBundles;
 771 »       »       »       »       vector·=·this.AddProductFromList(vector3,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.BundleRange,·1f,·false);
 772 »       »       »       »       float·num2·=·list[0].transform.position.y;
 773 »       »       »       »       for·(int·i·=·0;·i·<·list.Count;·i++)
773 »       »       »       »       {774 »       »       »       »       {
774 »       »       »       »       »       bundlePurchaseButton.UpdateBundle(); 
775 »       »       »       »       »       bundlePurchaseButton.PassiveButton.ClickMask·=·this.FeatureTabScroller.Hitbox; 
776 »       »       »       »       »       list.Add(bundlePurchaseButton);775 »       »       »       »       »       if·(this.allBundles[i].BundleSize·==·BundleSizes.Wide)
 776 »       »       »       »       »       {
 777 »       »       »       »       »       »       num2·=·list[i·-·this.selectedTabObject.NumPerRow].transform.position.y·-·list[i·-·this.selectedTabObject.NumPerRow].GetComponent<BoxCollider2D>().size.y·/·2f;
 778 »       »       »       »       »       »       list[i].transform.position·=·new·Vector3(list[i].transform.position.x,·num2·-·list[i].GetComponent<BoxCollider2D>().size.y·/·2f,·list[i].transform.position.z);
 779 »       »       »       »       »       }
777 »       »       »       »       }780 »       »       »       »       }
778 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Bundles,·Array.Empty<object>());781 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Bundles,·Array.Empty<object>());
779 »       »       »       »       this.FeatureTabScroller.Inner.localScale·=·Vector3.one·*·num; 
780 »       »       »       »       this.featuredMenu.SetActive(true); 
781 »       »       »       »       this.normalMenu.SetActive(false); 
782 »       »       »       »       break;782 »       »       »       »       break;
 783 »       »       »       }
783 »       »       »       case·StoreTab.Pets:784 »       »       »       case·StoreTab.Pets:
784 »       »       »       {785 »       »       »       {
785 »       »       »       »       Vector3·vector3·=·vector;786 »       »       »       »       Vector3·vector4·=·vector;
786 »       »       »       »       IBuyable[]·array·=·this.allPets;787 »       »       »       »       IBuyable[]·array·=·this.allPets;
787 »       »       »       »       vector·=·this.AddProductFromList(vector3,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);788 »       »       »       »       vector·=·this.AddProductFromList(vector4,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);
788 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PetLabel,·Array.Empty<object>());789 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.PetLabel,·Array.Empty<object>());
789 »       »       »       »       break;790 »       »       »       »       break;
790 »       »       »       }791 »       »       »       }
791 »       »       »       case·StoreTab.Stars:792 »       »       »       case·StoreTab.Stars:
792 »       »       »       {793 »       »       »       {
793 »       »       »       »       vector.y·+=·-0.975f;794 »       »       »       »       vector.y·+=·-0.975f;
794 »       »       »       »       Vector3·vector4·=·vector;795 »       »       »       »       Vector3·vector5·=·vector;
795 »       »       »       »       IBuyable[]·array·=·this.allStars;796 »       »       »       »       IBuyable[]·array·=·this.allStars;
796 »       »       »       »       vector·=·this.AddProductFromList(vector4,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);797 »       »       »       »       vector·=·this.AddProductFromList(vector5,·array,·list,·-3.9f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);
797 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Stars,·Array.Empty<object>());798 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Stars,·Array.Empty<object>());
798 »       »       »       »       break;799 »       »       »       »       break;
799 »       »       »       }800 »       »       »       }
800 »       »       »       case·StoreTab.Hats:801 »       »       »       case·StoreTab.Hats:
801 »       »       »       {802 »       »       »       {
802 »       »       »       »       Vector3·vector5·=·vector;803 »       »       »       »       Vector3·vector6·=·vector;
803 »       »       »       »       IBuyable[]·array·=·this.allHats;804 »       »       »       »       IBuyable[]·array·=·this.allHats;
804 »       »       »       »       vector·=·this.AddProductFromList(vector5,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);805 »       »       »       »       vector·=·this.AddProductFromList(vector6,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);
805 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HatLabel,·Array.Empty<object>());806 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.HatLabel,·Array.Empty<object>());
806 »       »       »       »       break;807 »       »       »       »       break;
807 »       »       »       }808 »       »       »       }
808 »       »       »       case·StoreTab.Skins:809 »       »       »       case·StoreTab.Skins:
809 »       »       »       {810 »       »       »       {
810 »       »       »       »       Vector3·vector6·=·vector;811 »       »       »       »       Vector3·vector7·=·vector;
811 »       »       »       »       IBuyable[]·array·=·this.allSkins;812 »       »       »       »       IBuyable[]·array·=·this.allSkins;
812 »       »       »       »       vector·=·this.AddProductFromList(vector6,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);813 »       »       »       »       vector·=·this.AddProductFromList(vector7,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);
813 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SkinLabel,·Array.Empty<object>());814 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.SkinLabel,·Array.Empty<object>());
814 »       »       »       »       break;815 »       »       »       »       break;
815 »       »       »       }816 »       »       »       }
816 »       »       »       case·StoreTab.Visors:817 »       »       »       case·StoreTab.Visors:
817 »       »       »       {818 »       »       »       {
818 »       »       »       »       Vector3·vector7·=·vector;819 »       »       »       »       Vector3·vector8·=·vector;
819 »       »       »       »       IBuyable[]·array·=·this.allVisors;820 »       »       »       »       IBuyable[]·array·=·this.allVisors;
820 »       »       »       »       vector·=·this.AddProductFromList(vector7,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);821 »       »       »       »       vector·=·this.AddProductFromList(vector8,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);
821 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Visors,·Array.Empty<object>());822 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Visors,·Array.Empty<object>());
822 »       »       »       »       break;823 »       »       »       »       break;
823 »       »       »       }824 »       »       »       }
824 »       »       »       case·StoreTab.Nameplates:825 »       »       »       case·StoreTab.Nameplates:
825 »       »       »       {826 »       »       »       {
826 »       »       »       »       Vector3·vector8·=·vector;827 »       »       »       »       Vector3·vector9·=·vector;
827 »       »       »       »       IBuyable[]·array·=·this.allPlates;828 »       »       »       »       IBuyable[]·array·=·this.allPlates;
828 »       »       »       »       vector·=·this.AddProductFromList(vector8,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);829 »       »       »       »       vector·=·this.AddProductFromList(vector9,·array,·list,·-1.95f,·this.selectedTabObject.NumPerRow,·this.selectedTabObject.XRange,·1f,·false);
829 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.NamePlates,·Array.Empty<object>());830 »       »       »       »       this.tabHeader.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.NamePlates,·Array.Empty<object>());
830 »       »       »       »       break;831 »       »       »       »       break;
831 »       »       »       }832 »       »       »       }
832 »       »       »       case·StoreTab.Home:833 »       »       »       case·StoreTab.Home:
 834 »       »       »       {
833 »       »       »       »       this.tabHeader.text·=·string.Empty;835 »       »       »       »       this.tabHeader.text·=·string.Empty;
 836 »       »       »       »       TextMeshPro·textMeshPro·=·Object.Instantiate<TextMeshPro>(this.tabHeader,·this.Scroller.Inner);
 837 »       »       »       »       textMeshPro.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.FeaturedItems,·Array.Empty<object>());
 838 »       »       »       »       textMeshPro.GetComponent<AspectPosition>().enabled·=·false;
 839 »       »       »       »       textMeshPro.horizontalAlignment·=·HorizontalAlignmentOptions.Center;
 840 »       »       »       »       textMeshPro.transform.position·=·Vector3.zero;
Max diff block lines reached; 4160/14094 bytes (29.52%) of diff not shown.
3.81 KB
Assembly-CSharp/StringNames.cs
    
Offset 571, 18 lines modifiedOffset 571, 47 lines modified
571 »       RolesHelpIntro_02,571 »       RolesHelpIntro_02,
572 »       RolesHelp_Scientist_01·=·1560,572 »       RolesHelp_Scientist_01·=·1560,
573 »       RolesHelp_Scientist_02,573 »       RolesHelp_Scientist_02,
574 »       RolesHelp_Engineer_01,574 »       RolesHelp_Engineer_01,
575 »       RolesHelp_Engineer_02,575 »       RolesHelp_Engineer_02,
576 »       RolesHelp_GuardianAngel_01,576 »       RolesHelp_GuardianAngel_01,
577 »       RolesHelp_GuardianAngel_02,577 »       RolesHelp_GuardianAngel_02,
 578 »       RolesHelp_Noisemaker_01,
 579 »       RolesHelp_Noisemaker_02,
 580 »       RolesHelp_Tracker_01,
 581 »       RolesHelp_Tracker_02,
578 »       RolesHelp_Shapeshifter_01·=·1600,582 »       RolesHelp_Shapeshifter_01·=·1600,
579 »       RolesHelp_Shapeshifter_02,583 »       RolesHelp_Shapeshifter_02,
 584 »       RolesHelp_Phantom_01,
 585 »       RolesHelp_Phantom_02,
580 »       RolesHelpOutro_01·=·1650,586 »       RolesHelpOutro_01·=·1650,
581 »       RolesHelpOutro_02,587 »       RolesHelpOutro_02,
 588 »       NoisemakerRole·=·1660,
 589 »       NoisemakerBlurb,
 590 »       NoisemakerBlurbMed,
 591 »       NoisemakerBlurbLong,
 592 »       NoisemakerImpostorAlert,
 593 »       NoisemakerAlertDuration,
 594 »       PhantomAbility·=·1670,
 595 »       PhantomRole,
 596 »       PhantomBlurb,
 597 »       PhantomBlurbMed,
 598 »       PhantomBlurbLong,
 599 »       PhantomCooldown,
 600 »       PhantomDuration,
 601 »       PhantomAbilityUndo,
 602 »       TrackerAbility·=·1680,
 603 »       TrackerRole,
 604 »       TrackerBlurb,
 605 »       TrackerBlurbMed,
 606 »       TrackerBlurbLong,
 607 »       TrackerCooldown,
 608 »       TrackerDuration,
 609 »       TrackerAbilityUndo,
 610 »       TrackerDelay,
582 »       SanctionDuration·=·1700,611 »       SanctionDuration·=·1700,
583 »       SanctionPermanent,612 »       SanctionPermanent,
584 »       SanctionConduct,613 »       SanctionConduct,
585 »       SanctionImpersonationCeleb,614 »       SanctionImpersonationCeleb,
586 »       SanctionSpamming,615 »       SanctionSpamming,
587 »       SanctionInappropriateNameUnsportsmanlike,616 »       SanctionInappropriateNameUnsportsmanlike,
588 »       SanctionUnsportsmanlikeConduct,617 »       SanctionUnsportsmanlikeConduct,
Offset 1305, 14 lines modifiedOffset 1334, 32 lines modified
1305 »       AccountDeleteHelp,1334 »       AccountDeleteHelp,
1306 »       AccountUnDeleteHelp,1335 »       AccountUnDeleteHelp,
1307 »       ConfirmDelete,1336 »       ConfirmDelete,
1308 »       ConfirmDeleteAccounts,1337 »       ConfirmDeleteAccounts,
1309 »       ConfirmDeleteAccountsEmpty,1338 »       ConfirmDeleteAccountsEmpty,
1310 »       AccountRequestDelete,1339 »       AccountRequestDelete,
1311 »       HasBeenKilled,1340 »       HasBeenKilled,
 1341 »       RoomSettingsLabel·=·3280,
 1342 »       ViewLabel,
 1343 »       RoomCodeLabel,
 1344 »       ModeLabel,
 1345 »       PrivacyLabel,
 1346 »       CapacityLabel,
 1347 »       GameSettingsLabel,
 1348 »       RoleSettingsLabel,
 1349 »       GamePresetsLabel,
 1350 »       GamePresetsDescription,
 1351 »       StandardRulesPresetDescription,
 1352 »       GameModeStandard,
 1353 »       GameModeStandardRoles,
 1354 »       GameModeCustom,
 1355 »       ReturnToLobby,
 1356 »       GameModeFlashlight,
 1357 »       HostNounLabel,
 1358 »       RoleSettingsAll,
1312 »       ScrollList·=·3300,1359 »       ScrollList·=·3300,
1313 »       ScrollNews,1360 »       ScrollNews,
1314 »       AmongUsAnnouncements,1361 »       AmongUsAnnouncements,
1315 »       AnnouncementErrorSubtitle,1362 »       AnnouncementErrorSubtitle,
1316 »       AnnouncementErrorText,1363 »       AnnouncementErrorText,
1317 »       ReadMoreLabel,1364 »       ReadMoreLabel,
1318 »       ReturnToList,1365 »       ReturnToList,
Offset 1332, 14 lines modifiedOffset 1379, 41 lines modified
1332 »       InventoryLabel,1379 »       InventoryLabel,
1333 »       StatsLabel,1380 »       StatsLabel,
1334 »       FriendsLabel,1381 »       FriendsLabel,
1335 »       ReportNotificationHeader,1382 »       ReportNotificationHeader,
1336 »       ReportNotificationBody,1383 »       ReportNotificationBody,
1337 »       MissingGuardianEmailText,1384 »       MissingGuardianEmailText,
1338 »       AprilFoolsModeToggle,1385 »       AprilFoolsModeToggle,
 1386 »       LobbyChangeSettingNotification,
 1387 »       ImpostorsCategory·=·3350,
 1388 »       RolesCategory,
 1389 »       MeetingsCategory,
 1390 »       PlayersCategory,
 1391 »       TasksCategory,
 1392 »       GameSettingsDescription,
 1393 »       RoleSettingsDescription,
 1394 »       InfoLabel,
 1395 »       RoleQuotaLabel,
 1396 »       OverviewCategory,
 1397 »       CrewmateRolesHeader,
 1398 »       ImpostorRolesHeader,
 1399 »       ViewingLabel,
 1400 »       LocalLobbyLabel,
 1401 »       NumberRoleHeader,
 1402 »       ChanceRoleHeader,
 1403 »       WaitingForPlayers,
 1404 »       HideAndSeekModeDescription,
 1405 »       RolesRulesPresetDescription,
 1406 »       FlashlightRulesPresetDescription,
 1407 »       RoomCodeCopied,
 1408 »       FinalHideCategory,
 1409 »       LobbyChangeSettingNotificationRole,
 1410 »       StandardRulesPresetDescriptionHideAndSeek,
 1411 »       GameModeStandardSeek,
 1412 »       HostYouLabel,
1339 »       MiningPit·=·3400,1413 »       MiningPit·=·3400,
1340 »       Jungle,1414 »       Jungle,
1341 »       BuildSandcastle,1415 »       BuildSandcastle,
1342 »       FishingDock,1416 »       FishingDock,
1343 »       CatchFish,1417 »       CatchFish,
1344 »       CollectShells,1418 »       CollectShells,
1345 »       LiftWeights,1419 »       LiftWeights,
Offset 1366, 14 lines modifiedOffset 1440, 17 lines modified
1366 »       WipeSand,1440 »       WipeSand,
1367 »       ExtractFuel,1441 »       ExtractFuel,
1368 »       MonitorMushroom,1442 »       MonitorMushroom,
1369 »       PlayVideogame,1443 »       PlayVideogame,
Max diff block lines reached; 854/3837 bytes (22.26%) of diff not shown.
3.42 KB
Assembly-CSharp/StringOption.cs
    
Offset 1, 66 lines modifiedOffset 1, 110 lines modified
1 using·System;1 using·System;
2 using·AmongUs.GameOptions;2 using·AmongUs.GameOptions;
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·StringOption·:·OptionBehaviour6 public·class·StringOption·:·OptionBehaviour
7 {7 {
8 »       public·void·OnEnable()8 »       public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer)
9 »       {9 »       {
10 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; 
11 »       »       StringNames·title·=·this.Title; 
12 »       »       if·(title·!=·StringNames.GameKillDistance)10 »       »       base.SetUpFromData(data,·maskLayer);
 11 »       »       StringGameSetting·stringGameSetting·=·data·as·StringGameSetting;
 12 »       »       if·(stringGameSetting·==·null)
13 »       »       {13 »       »       {
 14 »       »       »       return;
14 »       »       »       if·(title·!=·StringNames.GameTaskBarMode) 
15 »       »       »       { 
16 »       »       »       »       Debug.Log("Ono,·unrecognized·setting:·"·+·this.Title.ToString()); 
17 »       »       »       } 
18 »       »       »       else 
19 »       »       »       { 
20 »       »       »       »       currentGameOptions.TryGetInt(Int32OptionNames.TaskBarMode,·out·this.Value); 
21 »       »       »       } 
22 »       »       } 
23 »       »       else 
24 »       »       { 
25 »       »       »       currentGameOptions.TryGetInt(Int32OptionNames.KillDistance,·out·this.Value); 
26 »       »       }15 »       »       }
 16 »       »       this.Title·=·stringGameSetting.Title;
 17 »       »       this.Value·=·stringGameSetting.Index;
 18 »       »       this.Values·=·stringGameSetting.Values;
 19 »       »       this.stringOptionName·=·stringGameSetting.OptionName;
 20 »       }
 21
 22 »       private·void·Start()
 23 »       {
 24 »       »       this.Initialize();
 25 »       }
 26
 27 »       public·override·void·Initialize()
 28 »       {
 29 »       »       this.Value·=·(int)GameOptionsManager.Instance.CurrentGameOptions.GetValue(this.data);
27 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>());30 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>());
28 »       »       this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>());31 »       »       this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>());
 32 »       »       this.AdjustButtonsActiveState();
29 »       }33 »       }
30 34
31 »       private·void·FixedUpdate()35 »       private·void·FixedUpdate()
32 »       {36 »       {
33 »       »       if·(this.oldValue·!=·this.Value)37 »       »       if·(this.oldValue·!=·this.Value)
34 »       »       {38 »       »       {
35 »       »       »       this.oldValue·=·this.Value;39 »       »       »       this.oldValue·=·this.Value;
36 »       »       »       this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>());40 »       »       »       this.ValueText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Values[this.Value],·Array.Empty<object>());
37 »       »       }41 »       »       }
38 »       }42 »       }
39 43
40 »       public·void·Increase()44 »       public·void·Increase()
41 »       {45 »       {
42 »       »       this.Value·=·Mathf.Clamp(this.Value·+·1,·0,·this.Values.Length·-·1);46 »       »       this.Value·=·Mathf.Clamp(this.Value·+·1,·0,·this.Values.Length·-·1);
 47 »       »       this.UpdateValue();
43 »       »       this.OnValueChanged(this);48 »       »       this.OnValueChanged(this);
 49 »       »       this.AdjustButtonsActiveState();
44 »       }50 »       }
45 51
46 »       public·void·Decrease()52 »       public·void·Decrease()
47 »       {53 »       {
48 »       »       this.Value·=·Mathf.Clamp(this.Value·-·1,·0,·this.Values.Length·-·1);54 »       »       this.Value·=·Mathf.Clamp(this.Value·-·1,·0,·this.Values.Length·-·1);
 55 »       »       this.UpdateValue();
49 »       »       this.OnValueChanged(this);56 »       »       this.OnValueChanged(this);
 57 »       »       this.AdjustButtonsActiveState();
50 »       }58 »       }
51 59
52 »       public·override·int·GetInt()60 »       public·override·int·GetInt()
53 »       {61 »       {
54 »       »       return·this.Value;62 »       »       return·this.Value;
55 »       }63 »       }
56 64
 65 »       private·void·UpdateValue()
 66 »       {
 67 »       »       if·(this.stringOptionName·!=·Int32OptionNames.Invalid)
 68 »       »       {
 69 »       »       »       GameOptionsManager.Instance.CurrentGameOptions.SetInt(this.stringOptionName,·this.GetInt());
 70 »       »       »       return;
 71 »       »       }
 72 »       »       Debug.LogError("Could·not·update·value·of·"·+·this.Title.ToString());
 73 »       }
 74
 75 »       private·void·AdjustButtonsActiveState()
 76 »       {
 77 »       »       if·(this.Value·==·0)
 78 »       »       {
 79 »       »       »       this.MinusBtn.SetInteractable(false);
 80 »       »       »       this.PlusBtn.SetInteractable(true);
 81 »       »       »       return;
 82 »       »       }
 83 »       »       if·(this.Value·==·this.Values.Length·-·1)
 84 »       »       {
 85 »       »       »       this.MinusBtn.SetInteractable(true);
 86 »       »       »       this.PlusBtn.SetInteractable(false);
 87 »       »       »       return;
 88 »       »       }
 89 »       »       this.MinusBtn.SetInteractable(true);
 90 »       »       this.PlusBtn.SetInteractable(true);
 91 »       }
 92
57 »       public·TextMeshPro·TitleText;93 »       public·TextMeshPro·TitleText;
58 94
59 »       public·TextMeshPro·ValueText;95 »       public·TextMeshPro·ValueText;
60 96
61 »       public·StringNames[]·Values;97 »       public·StringNames[]·Values;
62 98
63 »       public·int·Value;99 »       public·int·Value;
64 100
65 »       private·int·oldValue·=·-1;101 »       private·int·oldValue·=·-1;
 102
 103 »       private·Int32OptionNames·stringOptionName;
 104
 105 »       [SerializeField]
 106 »       private·GameOptionButton·PlusBtn;
 107
 108 »       [SerializeField]
 109 »       private·GameOptionButton·MinusBtn;
66 }110 }
842 B
Assembly-CSharp/SystemConsole.cs
    
Offset 41, 15 lines modifiedOffset 41, 15 lines modified
41 »       »       {41 »       »       {
42 »       »       »       this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));42 »       »       »       this.Image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));
43 »       »       »       this.Image.material.SetColor("_OutlineColor",·Color.white);43 »       »       »       this.Image.material.SetColor("_OutlineColor",·Color.white);
44 »       »       »       this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear);44 »       »       »       this.Image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear);
45 »       »       }45 »       »       }
46 »       }46 »       }
47 47
48 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)48 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
49 »       {49 »       {
50 »       »       float·num·=·float.MaxValue;50 »       »       float·num·=·float.MaxValue;
51 »       »       PlayerControl·@object·=·pc.Object;51 »       »       PlayerControl·@object·=·pc.Object;
52 »       »       Vector2·truePosition·=·@object.GetTruePosition();52 »       »       Vector2·truePosition·=·@object.GetTruePosition();
53 »       »       couldUse·=·@object.CanMove·&&·base.enabled·&&·(!pc.IsDead·||·!(this.MinigamePrefab·is·EmergencyMinigame));53 »       »       couldUse·=·@object.CanMove·&&·base.enabled·&&·(!pc.IsDead·||·!(this.MinigamePrefab·is·EmergencyMinigame));
54 »       »       canUse·=·couldUse·&&·(!this.onlyFromBelow·||·truePosition.y·<·base.transform.position.y);54 »       »       canUse·=·couldUse·&&·(!this.onlyFromBelow·||·truePosition.y·<·base.transform.position.y);
55 »       »       if·(canUse)55 »       »       if·(canUse)
450 B
Assembly-CSharp/TakePartsMinigame.cs
Ordering differences only
    
Offset 103, 16 lines modifiedOffset 103, 16 lines modified
103 103
104 »       [SerializeField]104 »       [SerializeField]
105 »       private·GameObject·boxOpen;105 »       private·GameObject·boxOpen;
106 106
107 »       [SerializeField]107 »       [SerializeField]
108 »       private·GameObject·hand;108 »       private·GameObject·hand;
109 109
110 »       [SerializeField] 
111 »       [Header("Audio")]110 »       [Header("Audio")]
 111 »       [SerializeField]
112 »       private·AudioClip·openToolboxSfx;112 »       private·AudioClip·openToolboxSfx;
113 113
114 »       [SerializeField]114 »       [SerializeField]
115 »       private·AudioClip[]·pickUpSfx;115 »       private·AudioClip[]·pickUpSfx;
116 116
117 »       private·readonly·Controller·controller·=·new·Controller();117 »       private·readonly·Controller·controller·=·new·Controller();
118 118
1.24 KB
Assembly-CSharp/TaskAddButton.cs
    
Offset 32, 15 lines modifiedOffset 32, 15 lines modified
32 »       »       this.Button·=·base.GetComponent<PassiveButton>();32 »       »       this.Button·=·base.GetComponent<PassiveButton>();
33 »       }33 »       }
34 34
35 »       public·void·Start()35 »       public·void·Start()
36 »       {36 »       {
37 »       »       if·(this.Role)37 »       »       if·(this.Role)
38 »       »       {38 »       »       {
39 »       »       »       GameData.PlayerInfo·data·=·PlayerControl.LocalPlayer.Data;39 »       »       »       NetworkedPlayerInfo·data·=·PlayerControl.LocalPlayer.Data;
40 »       »       »       this.Overlay.enabled·=·data.Role.Role·==·this.Role.Role;40 »       »       »       this.Overlay.enabled·=·data.Role.Role·==·this.Role.Role;
41 »       »       »       this.Overlay.sprite·=·this.CheckImage;41 »       »       »       this.Overlay.sprite·=·this.CheckImage;
42 »       »       »       return;42 »       »       »       return;
43 »       »       }43 »       »       }
44 »       »       PlayerTask·playerTask·=·this.FindTaskByType();44 »       »       PlayerTask·playerTask·=·this.FindTaskByType();
45 »       »       if·(playerTask)45 »       »       if·(playerTask)
46 »       »       {46 »       »       {
Offset 65, 15 lines modifiedOffset 65, 15 lines modified
65 »       »       {65 »       »       {
66 »       »       »       if·(PlayerControl.LocalPlayer.Data.Role.Role·!=·this.Role.Role)66 »       »       »       if·(PlayerControl.LocalPlayer.Data.Role.Role·!=·this.Role.Role)
67 »       »       »       {67 »       »       »       {
68 »       »       »       »       if·(PlayerTask.DestroyTasksOfType<ImportantTextTask>(PlayerControl.LocalPlayer)·&&·!PlayerTask.PlayerHasTaskOfType<NormalPlayerTask>(PlayerControl.LocalPlayer))68 »       »       »       »       if·(PlayerTask.DestroyTasksOfType<ImportantTextTask>(PlayerControl.LocalPlayer)·&&·!PlayerTask.PlayerHasTaskOfType<NormalPlayerTask>(PlayerControl.LocalPlayer))
69 »       »       »       »       {69 »       »       »       »       {
70 »       »       »       »       »       ShipStatus.Instance.Begin();70 »       »       »       »       »       ShipStatus.Instance.Begin();
71 »       »       »       »       }71 »       »       »       »       }
72 »       »       »       »       PlayerControl.LocalPlayer.RpcSetRole(this.Role.Role);72 »       »       »       »       PlayerControl.LocalPlayer.RpcSetRole(this.Role.Role,·false);
73 »       »       »       »       PlayerControl.LocalPlayer.transform.position·=·this.SafePositionWorld;73 »       »       »       »       PlayerControl.LocalPlayer.transform.position·=·this.SafePositionWorld;
74 »       »       »       »       ImpostorGhostRole·impostorGhostRole·=·PlayerControl.LocalPlayer.Data.Role·as·ImpostorGhostRole;74 »       »       »       »       ImpostorGhostRole·impostorGhostRole·=·PlayerControl.LocalPlayer.Data.Role·as·ImpostorGhostRole;
75 »       »       »       »       if·(impostorGhostRole·!=·null)75 »       »       »       »       if·(impostorGhostRole·!=·null)
76 »       »       »       »       {76 »       »       »       »       {
77 »       »       »       »       »       impostorGhostRole.WasManuallyPicked·=·true;77 »       »       »       »       »       impostorGhostRole.WasManuallyPicked·=·true;
78 »       »       »       »       }78 »       »       »       »       }
79 »       »       »       }79 »       »       »       }
743 B
Assembly-CSharp/TestFrisbeeMinigame.cs
Ordering differences only
    
Offset 131, 21 lines modifiedOffset 131, 21 lines modified
131 »       [ContextMenu("Reset·Frisbee·Position")]131 »       [ContextMenu("Reset·Frisbee·Position")]
132 »       private·void·ResetFrisbeePosition()132 »       private·void·ResetFrisbeePosition()
133 »       {133 »       {
134 »       »       this.throwableFrisbee.transform.localPosition·=·this.originalFrisbeePosition;134 »       »       this.throwableFrisbee.transform.localPosition·=·this.originalFrisbeePosition;
135 »       »       this.throwableFrisbee.transform.localScale·=·Vector3.one;135 »       »       this.throwableFrisbee.transform.localScale·=·Vector3.one;
136 »       }136 »       }
137 137
138 »       [Header("Design·Values")] 
139 »       [SerializeField]138 »       [SerializeField]
 139 »       [Header("Design·Values")]
140 »       [Range(0.5f,·0.99f)]140 »       [Range(0.5f,·0.99f)]
141 »       private·float·pickUpAnalogThresshold·=·0.9f;141 »       private·float·pickUpAnalogThresshold·=·0.9f;
142 142
143 »       [Header("Components")] 
144 »       [SerializeField]143 »       [SerializeField]
 144 »       [Header("Components")]
145 »       private·PassiveButton·stuckFrisbee;145 »       private·PassiveButton·stuckFrisbee;
146 146
147 »       [SerializeField]147 »       [SerializeField]
148 »       private·Collider2D·throwableFrisbee;148 »       private·Collider2D·throwableFrisbee;
149 149
150 »       [SerializeField]150 »       [SerializeField]
151 »       private·SpriteAnim·sparkle;151 »       private·SpriteAnim·sparkle;
6.9 KB
Assembly-CSharp/TextBoxTMP.cs
    
Offset 36, 43 lines modifiedOffset 36, 45 lines modified
36 »       »       {36 »       »       {
37 »       »       »       DestroyableSingleton<PassiveButtonManager>.Instance.RemoveOne(this);37 »       »       »       DestroyableSingleton<PassiveButtonManager>.Instance.RemoveOne(this);
38 »       »       }38 »       »       }
39 »       }39 »       }
40 40
41 »       public·void·Clear()41 »       public·void·Clear()
42 »       {42 »       {
 43 »       »       this.SetCaretPosition(0);
43 »       »       this.SetText(string.Empty,·string.Empty);44 »       »       this.SetText(string.Empty,·string.Empty);
44 »       }45 »       }
45 46
46 »       public·void·Update()47 »       public·void·Update()
47 »       {48 »       {
48 »       »       if·(!base.enabled)49 »       »       if·(!base.enabled)
49 »       »       {50 »       »       {
50 »       »       »       return;51 »       »       »       return;
51 »       »       }52 »       »       }
52 »       »       if·(!this.hasFocus)53 »       »       if·(!this.hasFocus)
53 »       »       {54 »       »       {
54 »       »       »       return;55 »       »       »       return;
55 »       »       }56 »       »       }
 57 »       »       this.MoveCaret();
56 »       »       if·(this.AllowPaste·&&·(Input.GetKey(KeyCode.LeftControl)·||·Input.GetKey(KeyCode.RightControl))·&&·Input.GetKeyDown(KeyCode.V))58 »       »       if·(this.AllowPaste·&&·(Input.GetKey(KeyCode.LeftControl)·||·Input.GetKey(KeyCode.RightControl))·&&·Input.GetKeyDown(KeyCode.V))
57 »       »       {59 »       »       {
58 »       »       »       string·clipboardString·=·ClipboardHelper.GetClipboardString();60 »       »       »       string·clipboardString·=·ClipboardHelper.GetClipboardString();
59 »       »       »       if·(!string.IsNullOrWhiteSpace(clipboardString))61 »       »       »       if·(!string.IsNullOrWhiteSpace(clipboardString))
60 »       »       »       {62 »       »       »       {
61 »       »       »       »       this.SetText(this.text·+·clipboardString,·"");63 »       »       »       »       this.SetText(this.text.Insert(this.caretPos,·clipboardString),·"");
62 »       »       »       }64 »       »       »       }
63 »       »       }65 »       »       }
64 »       »       string·inputString·=·Input.inputString;66 »       »       string·inputString·=·Input.inputString;
65 »       »       if·(inputString.Length·>·0·||·this.compoText·!=·Input.compositionString)67 »       »       if·(inputString.Length·>·0·||·this.compoText·!=·Input.compositionString)
66 »       »       {68 »       »       {
67 »       »       »       if·(this.text·==·null·||·this.text·==·"Enter·Name")69 »       »       »       if·(this.text·==·null·||·this.text·==·"Enter·Name")
68 »       »       »       {70 »       »       »       {
69 »       »       »       »       this.text·=·"";71 »       »       »       »       this.text·=·"";
70 »       »       »       }72 »       »       »       }
71 »       »       »       this.SetText(this.text·+·inputString,·Input.compositionString);73 »       »       »       this.SetText(this.text.Insert(this.caretPos,·inputString),·Input.compositionString);
72 »       »       }74 »       »       }
73 »       »       if·(this.Pipe·&&·this.hasFocus)75 »       »       if·(this.Pipe·&&·this.hasFocus)
74 »       »       {76 »       »       {
75 »       »       »       this.pipeBlinkTimer·+=·Time.deltaTime·*·2f;77 »       »       »       this.pipeBlinkTimer·+=·Time.deltaTime·*·2f;
76 »       »       »       this.Pipe.enabled·=·(int)this.pipeBlinkTimer·%·2·==·0;78 »       »       »       this.Pipe.enabled·=·(int)this.pipeBlinkTimer·%·2·==·0;
77 »       »       }79 »       »       }
78 »       }80 »       }
Offset 97, 28 lines modifiedOffset 99, 30 lines modified
97 »       »       »       return;99 »       »       »       return;
98 »       »       }100 »       »       }
99 »       »       if·(this.ClearOnFocus)101 »       »       if·(this.ClearOnFocus)
100 »       »       {102 »       »       {
101 »       »       »       this.text·=·string.Empty;103 »       »       »       this.text·=·string.Empty;
102 »       »       »       this.compoText·=·string.Empty;104 »       »       »       this.compoText·=·string.Empty;
103 »       »       »       this.outputText.text·=·string.Empty;105 »       »       »       this.outputText.text·=·string.Empty;
 106 »       »       »       this.SetCaretPosition(0);
104 »       »       }107 »       »       }
105 »       »       this.hasFocus·=·true;108 »       »       this.hasFocus·=·true;
106 »       »       if·(TouchScreenKeyboard.isSupported)109 »       »       if·(TouchScreenKeyboard.isSupported)
107 »       »       {110 »       »       {
108 »       »       »       this.keyboard·=·TouchScreenKeyboard.Open(this.text);111 »       »       »       this.keyboard·=·TouchScreenKeyboard.Open(this.text);
109 »       »       }112 »       »       }
110 »       »       if·(this.Background)113 »       »       if·(this.Background)
111 »       »       {114 »       »       {
112 »       »       »       this.Background.color·=·Color.green;115 »       »       »       this.Background.color·=·Color.green;
113 »       »       }116 »       »       }
114 »       »       this.pipeBlinkTimer·=·0f;117 »       »       this.pipeBlinkTimer·=·0f;
115 »       »       if·(this.Pipe)118 »       »       if·(this.Pipe)
116 »       »       {119 »       »       {
117 »       »       »       this.Pipe.transform.localPosition·=·this.outputText.CursorPos();120 »       »       »       this.SetPipePosition();
 121 »       »       »       this.SetCaretPosition(this.outputText.text.Length);
118 »       »       }122 »       »       }
119 »       }123 »       }
120 124
121 »       public·void·ForceKeyboardClose()125 »       public·void·ForceKeyboardClose()
122 »       {126 »       {
123 »       »       if·(this.keyboard·!=·null)127 »       »       if·(this.keyboard·!=·null)
124 »       »       {128 »       »       {
Offset 174, 42 lines modifiedOffset 178, 54 lines modified
174 »       »       }178 »       »       }
175 »       »       return·false;179 »       »       return·false;
176 »       }180 »       }
177 181
178 »       public·void·SetText(string·input,·string·inputCompo·=·"")182 »       public·void·SetText(string·input,·string·inputCompo·=·"")
179 »       {183 »       {
180 »       »       bool·flag·=·false;184 »       »       bool·flag·=·false;
 185 »       »       this.AdjustCaretPosition(input.Length·-·this.text.Length);
181 »       »       char·c·=·'·';186 »       »       char·c·=·'·';
182 »       »       this.tempTxt.Clear();187 »       »       this.tempTxt.Clear();
183 »       »       foreach·(char·c2·in·input)188 »       »       foreach·(char·c2·in·input)
184 »       »       {189 »       »       {
185 »       »       »       if·(c·!=·'·'·||·c2·!=·'·')190 »       »       »       if·(c·==·'·'·&&·c2·==·'·')
 191 »       »       »       {
 192 »       »       »       »       this.AdjustCaretPosition(-1);
 193 »       »       »       }
 194 »       »       »       else
186 »       »       »       {195 »       »       »       {
187 »       »       »       »       if·(c2·==·'\r'·||·c2·==·'\n')196 »       »       »       »       if·(c2·==·'\r'·||·c2·==·'\n')
188 »       »       »       »       {197 »       »       »       »       {
189 »       »       »       »       »       flag·=·true;198 »       »       »       »       »       flag·=·true;
190 »       »       »       »       }199 »       »       »       »       }
191 »       »       »       »       if·(c2·==·'\b')200 »       »       »       »       if·(c2·==·'\b')
192 »       »       »       »       {201 »       »       »       »       {
193 »       »       »       »       »       this.tempTxt.Length·=·Math.Max(this.tempTxt.Length·-·1,·0);202 »       »       »       »       »       this.tempTxt.Length·=·Math.Max(this.tempTxt.Length·-·1,·0);
 203 »       »       »       »       »       this.AdjustCaretPosition(-1);
194 »       »       »       »       }204 »       »       »       »       }
195 »       »       »       »       if·(this.ForceUppercase)205 »       »       »       »       if·(this.ForceUppercase)
196 »       »       »       »       {206 »       »       »       »       {
197 »       »       »       »       »       c2·=·char.ToUpperInvariant(c2);207 »       »       »       »       »       c2·=·char.ToUpperInvariant(c2);
198 »       »       »       »       }208 »       »       »       »       }
199 »       »       »       »       if·(this.IsCharAllowed(c2))209 »       »       »       »       if·(!this.IsCharAllowed(c2))
 210 »       »       »       »       {
 211 »       »       »       »       »       this.AdjustCaretPosition(-1);
 212 »       »       »       »       }
 213 »       »       »       »       else
200 »       »       »       »       {214 »       »       »       »       {
201 »       »       »       »       »       this.tempTxt.Append(c2);215 »       »       »       »       »       this.tempTxt.Append(c2);
202 »       »       »       »       »       c·=·c2;216 »       »       »       »       »       c·=·c2;
203 »       »       »       »       }217 »       »       »       »       }
204 »       »       »       }218 »       »       »       }
205 »       »       }219 »       »       }
206 »       »       if·(!this.tempTxt.ToString().Equals(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.EnterName,·Array.Empty<object>()),·StringComparison.OrdinalIgnoreCase)·&&·this.characterLimit·>·0)220 »       »       if·(!this.tempTxt.ToString().Equals(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.EnterName,·Array.Empty<object>()),·StringComparison.OrdinalIgnoreCase)·&&·this.characterLimit·>·0)
207 »       »       {221 »       »       {
 222 »       »       »       int·length·=·this.tempTxt.Length;
208 »       »       »       this.tempTxt.Length·=·Math.Min(this.tempTxt.Length,·this.characterLimit);223 »       »       »       this.tempTxt.Length·=·Math.Min(this.tempTxt.Length,·this.characterLimit);
 224 »       »       »       this.AdjustCaretPosition(-(length·-·this.tempTxt.Length));
209 »       »       }225 »       »       }
210 »       »       input·=·this.tempTxt.ToString();226 »       »       input·=·this.tempTxt.ToString();
211 »       »       if·(!input.Equals(this.text)·||·!inputCompo.Equals(this.compoText))227 »       »       if·(!input.Equals(this.text)·||·!inputCompo.Equals(this.compoText))
Max diff block lines reached; 3493/7009 bytes (49.84%) of diff not shown.
432 B
Assembly-CSharp/TextController.cs
Ordering differences only
    
Offset 1, 12 lines modifiedOffset 1, 12 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 [RequireComponent(typeof(MeshFilter))] 
5 [RequireComponent(typeof(MeshRenderer))]4 [RequireComponent(typeof(MeshRenderer))]
 5 [RequireComponent(typeof(MeshFilter))]
6 public·class·TextController·:·MonoBehaviour6 public·class·TextController·:·MonoBehaviour
7 {7 {
8 »       public·void·Update()8 »       public·void·Update()
9 »       {9 »       {
10 »       »       if·(!this.rend)10 »       »       if·(!this.rend)
11 »       »       {11 »       »       {
12 »       »       »       this.rend·=·base.GetComponent<MeshRenderer>();12 »       »       »       this.rend·=·base.GetComponent<MeshRenderer>();
1.24 KB
Assembly-CSharp/TextMeshProExtensions.cs
    
Offset 11, 14 lines modifiedOffset 11, 31 lines modified
11 »       »       if·((double)self.renderedHeight·>·100000000.0·||·(double)self.renderedHeight·<·-100000000.0)11 »       »       if·((double)self.renderedHeight·>·100000000.0·||·(double)self.renderedHeight·<·-100000000.0)
12 »       »       {12 »       »       {
13 »       »       »       return·0f;13 »       »       »       return·0f;
14 »       »       }14 »       »       }
15 »       »       return·self.renderedHeight;15 »       »       return·self.renderedHeight;
16 »       }16 »       }
17 17
 18 »       public·static·Vector2·CursorPos(this·TextMeshPro·self,·int·caretPos)
 19 »       {
 20 »       »       if·(self.textInfo·==·null·||·self.textInfo.lineCount·==·0·||·self.textInfo.lineInfo[0].characterCount·<=·0)
 21 »       »       {
 22 »       »       »       return·Vector2.zero;
 23 »       »       }
 24 »       »       if·(self.textInfo.lineCount·==·2)
 25 »       »       {
 26 »       »       »       return·new·Vector2(self.textInfo.characterInfo[caretPos·-·1].topRight.x·-·0.01f,·(float)Mathf.Abs(self.textInfo.characterInfo[caretPos·-·1].lineNumber·-·1)·*·0.24f);
 27 »       »       }
 28 »       »       if·(caretPos·==·0)
 29 »       »       {
 30 »       »       »       return·new·Vector2(self.textInfo.characterInfo[0].topLeft.x·-·0.01f,·0.12f);
 31 »       »       }
 32 »       »       return·new·Vector2(self.textInfo.characterInfo[caretPos·-·1].topRight.x·-·0.01f,·0.12f);
 33 »       }
 34
18 »       public·static·Vector2·CursorPos(this·TextMeshPro·self)35 »       public·static·Vector2·CursorPos(this·TextMeshPro·self)
19 »       {36 »       {
20 »       »       if·(self.textInfo·==·null·||·self.textInfo.lineCount·==·0·||·self.textInfo.lineInfo[0].characterCount·<=·0)37 »       »       if·(self.textInfo·==·null·||·self.textInfo.lineCount·==·0·||·self.textInfo.lineInfo[0].characterCount·<=·0)
21 »       »       {38 »       »       {
22 »       »       »       return·Vector2.zero;39 »       »       »       return·Vector2.zero;
23 »       »       }40 »       »       }
24 »       »       return·Enumerable.Last<TMP_LineInfo>(self.textInfo.lineInfo,·(TMP_LineInfo·l)·=>·l.characterCount·>·0).lineExtents.max;41 »       »       return·Enumerable.Last<TMP_LineInfo>(self.textInfo.lineInfo,·(TMP_LineInfo·l)·=>·l.characterCount·>·0).lineExtents.max;
3.62 KB
Assembly-CSharp/ToggleOption.cs
    
Offset 1, 69 lines modifiedOffset 1, 35 lines modified
1 using·System;1 using·System;
2 using·AmongUs.GameOptions;2 using·AmongUs.GameOptions;
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·ToggleOption·:·OptionBehaviour6 public·class·ToggleOption·:·OptionBehaviour
7 {7 {
8 »       public·void·OnEnable()8 »       public·override·void·SetUpFromData(BaseGameSetting·data,·int·maskLayer)
9 »       {9 »       {
 10 »       »       base.SetUpFromData(data,·maskLayer);
 11 »       »       CheckboxGameSetting·checkboxGameSetting·=·data·as·CheckboxGameSetting;
 12 »       »       if·(checkboxGameSetting·==·null)
10 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>()); 
11 »       »       IGameOptions·currentGameOptions·=·GameOptionsManager.Instance.CurrentGameOptions; 
12 »       »       StringNames·title·=·this.Title; 
13 »       »       if·(title·<=·StringNames.GameAnonymousVotes) 
14 »       »       { 
15 »       »       »       if·(title·==·StringNames.GameRecommendedSettings) 
16 »       »       »       { 
17 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.IsDefaults); 
18 »       »       »       »       return; 
19 »       »       »       } 
20 »       »       »       switch·(title) 
21 »       »       »       { 
22 »       »       »       case·StringNames.GameConfirmImpostor: 
23 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.ConfirmImpostor); 
24 »       »       »       »       return; 
25 »       »       »       case·StringNames.GameVisualTasks: 
26 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.VisualTasks); 
27 »       »       »       »       return; 
28 »       »       »       case·StringNames.GameAnonymousVotes: 
29 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.AnonymousVotes); 
30 »       »       »       »       return; 
31 »       »       »       } 
32 »       »       } 
33 »       »       else 
34 »       »       {13 »       »       {
35 »       »       »       if·(title·==·StringNames.UseFlashlight) 
36 »       »       »       { 
37 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.UseFlashlight); 
38 »       »       »       »       return;14 »       »       »       return;
39 »       »       »       } 
40 »       »       »       switch·(title) 
41 »       »       »       { 
42 »       »       »       case·StringNames.SeekerFinalVents: 
43 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.SeekerFinalVents); 
44 »       »       »       »       return; 
45 »       »       »       case·StringNames.SeekerFinalMap: 
46 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.SeekerFinalMap); 
47 »       »       »       »       return; 
48 »       »       »       case·StringNames.CrewmateVentCooldown: 
49 »       »       »       »       break; 
50 »       »       »       case·StringNames.SeekerPings: 
51 »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.SeekerPings); 
52 »       »       »       »       return; 
53 »       »       »       default: 
54 »       »       »       »       if·(title·==·StringNames.ShowCrewmateNames) 
55 »       »       »       »       { 
56 »       »       »       »       »       this.CheckMark.enabled·=·currentGameOptions.GetBool(BoolOptionNames.ShowCrewmateNames); 
57 »       »       »       »       »       return; 
58 »       »       »       »       } 
59 »       »       »       »       break; 
60 »       »       »       } 
61 »       »       }15 »       »       }
62 »       »       Debug.Log("Ono,·unrecognized·setting:·"·+·this.Title.ToString());16 »       »       this.Title·=·checkboxGameSetting.Title;
 17 »       »       this.boolOptionName·=·checkboxGameSetting.OptionName;
 18 »       }
 19
 20 »       private·void·Start()
 21 »       {
 22 »       »       this.Initialize();
 23 »       }
 24
 25 »       public·override·void·Initialize()
 26 »       {
 27 »       »       this.TitleText.text·=·DestroyableSingleton<TranslationController>.Instance.GetString(this.Title,·Array.Empty<object>());
 28 »       »       this.CheckMark.enabled·=·GameOptionsManager.Instance.CurrentGameOptions.GetValue(this.data)·==·1f;
63 »       }29 »       }
64 30
65 »       private·void·FixedUpdate()31 »       private·void·FixedUpdate()
66 »       {32 »       {
67 »       »       bool·@bool·=·this.GetBool();33 »       »       bool·@bool·=·this.GetBool();
68 »       »       if·(this.oldValue·!=·@bool)34 »       »       if·(this.oldValue·!=·@bool)
69 »       »       {35 »       »       {
Offset 71, 21 lines modifiedOffset 37, 34 lines modified
71 »       »       »       this.CheckMark.enabled·=·@bool;37 »       »       »       this.CheckMark.enabled·=·@bool;
72 »       »       }38 »       »       }
73 »       }39 »       }
74 40
75 »       public·void·Toggle()41 »       public·void·Toggle()
76 »       {42 »       {
77 »       »       this.CheckMark.enabled·=·!this.CheckMark.enabled;43 »       »       this.CheckMark.enabled·=·!this.CheckMark.enabled;
 44 »       »       this.UpdateValue();
78 »       »       this.OnValueChanged(this);45 »       »       this.OnValueChanged(this);
79 »       }46 »       }
80 47
81 »       public·override·bool·GetBool()48 »       public·override·bool·GetBool()
82 »       {49 »       {
83 »       »       return·this.CheckMark.enabled;50 »       »       return·this.CheckMark.enabled;
84 »       }51 »       }
85 52
 53 »       private·void·UpdateValue()
 54 »       {
 55 »       »       if·(this.boolOptionName·!=·BoolOptionNames.Invalid)
 56 »       »       {
 57 »       »       »       GameOptionsManager.Instance.CurrentGameOptions.SetBool(this.boolOptionName,·this.GetBool());
 58 »       »       »       return;
 59 »       »       }
 60 »       »       Debug.LogError("Could·not·update·value·of·"·+·this.Title.ToString());
 61 »       }
 62
86 »       public·TextMeshPro·TitleText;63 »       public·TextMeshPro·TitleText;
87 64
88 »       public·SpriteRenderer·CheckMark;65 »       public·SpriteRenderer·CheckMark;
89 66
90 »       private·bool·oldValue;67 »       private·bool·oldValue;
 68
 69 »       private·BoolOptionNames·boolOptionName;
91 }70 }
2.88 KB
Assembly-CSharp/TutorialManager.cs
    
Offset 39, 44 lines modifiedOffset 39, 44 lines modified
39 »       »       {39 »       »       {
40 »       »       »       yield·return·null;40 »       »       »       yield·return·null;
41 »       »       }41 »       »       }
42 »       »       if·(DestroyableSingleton<DiscordManager>.InstanceExists)42 »       »       if·(DestroyableSingleton<DiscordManager>.InstanceExists)
43 »       »       {43 »       »       {
44 »       »       »       DestroyableSingleton<DiscordManager>.Instance.SetHowToPlay();44 »       »       »       DestroyableSingleton<DiscordManager>.Instance.SetHowToPlay();
45 »       »       }45 »       »       }
46 »       »       NormalGameOptionsV07·normalGameOptionsV·=·new·NormalGameOptionsV07(new·UnityLogger());46 »       »       NormalGameOptionsV08·normalGameOptionsV·=·new·NormalGameOptionsV08(new·UnityLogger());
47 »       »       normalGameOptionsV.SetInt(Int32OptionNames.NumImpostors,·0);47 »       »       normalGameOptionsV.SetInt(Int32OptionNames.NumImpostors,·0);
48 »       »       normalGameOptionsV.DiscussionTime·=·0;48 »       »       normalGameOptionsV.DiscussionTime·=·0;
49 »       »       normalGameOptionsV.NumEmergencyMeetings·=·9;49 »       »       normalGameOptionsV.NumEmergencyMeetings·=·9;
50 »       »       normalGameOptionsV.GhostsDoTasks·=·true;50 »       »       normalGameOptionsV.GhostsDoTasks·=·true;
51 »       »       GameOptionsManager.Instance.CurrentGameOptions·=·normalGameOptionsV;51 »       »       GameOptionsManager.Instance.CurrentGameOptions·=·normalGameOptionsV;
52 »       »       PlayerControl.LocalPlayer.RpcSetRole(RoleTypes.Crewmate);52 »       »       PlayerControl.LocalPlayer.RpcSetRole(RoleTypes.Crewmate,·false);
53 »       »       PlayerControl.LocalPlayer.AdjustLighting();53 »       »       PlayerControl.LocalPlayer.AdjustLighting();
54 »       »       PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer();54 »       »       PlayerControl.LocalPlayer.cosmetics.SetAsLocalPlayer();
55 »       »       for·(int·i·=·0;·i·<·ShipStatus.Instance.DummyLocations.Length;·i++)55 »       »       for·(int·i·=·0;·i·<·ShipStatus.Instance.DummyLocations.Length;·i++)
56 »       »       {56 »       »       {
57 »       »       »       PlayerControl·playerControl·=·Object.Instantiate<PlayerControl>(this.PlayerPrefab);57 »       »       »       PlayerControl·playerControl·=·Object.Instantiate<PlayerControl>(this.PlayerPrefab);
58 »       »       »       playerControl.PlayerId·=·(byte)GameData.Instance.GetAvailableId();58 »       »       »       playerControl.PlayerId·=·(byte)GameData.Instance.GetAvailableId();
59 »       »       »       GameData.PlayerInfo·playerInfo·=·GameData.Instance.AddPlayer(playerControl);59 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·GameData.Instance.AddDummy(playerControl);
 60 »       »       »       AmongUsClient.Instance.Spawn(networkedPlayerInfo,·-2,·SpawnFlags.None);
60 »       »       »       AmongUsClient.Instance.Spawn(playerControl,·-2,·SpawnFlags.None);61 »       »       »       AmongUsClient.Instance.Spawn(playerControl,·-2,·SpawnFlags.None);
61 »       »       »       playerInfo.DefaultOutfit.dontCensorName·=·true; 
62 »       »       »       playerControl.isDummy·=·true;62 »       »       »       playerControl.isDummy·=·true;
63 »       »       »       playerControl.transform.position·=·ShipStatus.Instance.DummyLocations[i].position;63 »       »       »       playerControl.transform.position·=·ShipStatus.Instance.DummyLocations[i].position;
64 »       »       »       playerControl.GetComponent<DummyBehaviour>().enabled·=·true;64 »       »       »       playerControl.GetComponent<DummyBehaviour>().enabled·=·true;
65 »       »       »       playerControl.NetTransform.enabled·=·false;65 »       »       »       playerControl.NetTransform.enabled·=·false;
66 »       »       »       playerControl.SetName(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Dummy,·Array.Empty<object>())·+·"·"·+·(i·+·1).ToString(),·true);66 »       »       »       playerControl.SetName(DestroyableSingleton<TranslationController>.Instance.GetString(StringNames.Dummy,·Array.Empty<object>())·+·"·"·+·(i·+·1).ToString());
67 »       »       »       byte·b·=·(byte)((i·<·(int)DataManager.Player.Customization.Color)·?·i·:·(i·+·1));67 »       »       »       byte·b·=·(byte)((i·<·(int)DataManager.Player.Customization.Color)·?·i·:·(i·+·1));
68 »       »       »       playerControl.SetColor((int)b);68 »       »       »       playerControl.SetColor((int)b);
69 »       »       »       playerControl.SetHat("",·(int)b);69 »       »       »       playerControl.SetHat("",·(int)b);
70 »       »       »       playerControl.SetSkin("",·(int)b);70 »       »       »       playerControl.SetSkin("",·(int)b);
71 »       »       »       playerControl.SetPet("");71 »       »       »       playerControl.SetPet("");
72 »       »       »       playerControl.SetVisor("",·(int)b);72 »       »       »       playerControl.SetVisor("",·(int)b);
73 »       »       »       playerControl.SetNamePlate("");73 »       »       »       playerControl.SetNamePlate("");
74 »       »       »       playerControl.SetLevel(0U);74 »       »       »       playerControl.SetLevel(0U);
75 »       »       »       GameData.Instance.RpcSetTasks(playerControl.PlayerId,·new·byte[0]);75 »       »       »       networkedPlayerInfo.RpcSetTasks(new·byte[0]);
76 »       »       }76 »       »       }
77 »       »       yield·return·ShipStatus.Instance.CosmeticsCache.PopulateFromPlayers();77 »       »       yield·return·ShipStatus.Instance.CosmeticsCache.PopulateFromPlayers();
78 »       »       ShipStatus.Instance.Begin();78 »       »       ShipStatus.Instance.Begin();
79 »       »       GameManager.Instance.StartGame();79 »       »       GameManager.Instance.StartGame();
80 »       »       ShipStatus.Instance.StartSFX();80 »       »       ShipStatus.Instance.StartSFX();
81 »       »       global::Logger.GlobalInstance.Info(string.Format("Started·Freeplay·Game·in·{0}",·(MapNames)AmongUsClient.Instance.TutorialMapId),·null);81 »       »       global::Logger.GlobalInstance.Info(string.Format("Started·Freeplay·Game·in·{0}",·(MapNames)AmongUsClient.Instance.TutorialMapId),·null);
82 »       »       yield·break;82 »       »       yield·break;
775 B
Assembly-CSharp/Vent.cs
    
Offset 105, 15 lines modifiedOffset 105, 15 lines modified
105 »       »       »       else105 »       »       »       else
106 »       »       »       {106 »       »       »       {
107 »       »       »       »       buttonBehavior.gameObject.SetActive(false);107 »       »       »       »       buttonBehavior.gameObject.SetActive(false);
108 »       »       »       }108 »       »       »       }
109 »       »       }109 »       »       }
110 »       }110 »       }
111 111
112 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)112 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
113 »       {113 »       {
114 »       »       float·num·=·float.MaxValue;114 »       »       float·num·=·float.MaxValue;
115 »       »       PlayerControl·@object·=·pc.Object;115 »       »       PlayerControl·@object·=·pc.Object;
116 »       »       couldUse·=·pc.Role.CanVent·&&·GameManager.Instance.LogicUsables.CanUse(this,·@object)·&&·pc.Role.CanUse(this)·&&·(!@object.MustCleanVent(this.Id)·||·(@object.inVent·&&·Vent.currentVent·==·this))·&&·!pc.IsDead·&&·(@object.CanMove·||·@object.inVent);116 »       »       couldUse·=·pc.Role.CanVent·&&·GameManager.Instance.LogicUsables.CanUse(this,·@object)·&&·pc.Role.CanUse(this)·&&·(!@object.MustCleanVent(this.Id)·||·(@object.inVent·&&·Vent.currentVent·==·this))·&&·!pc.IsDead·&&·(@object.CanMove·||·@object.inVent);
117 »       »       ISystemType·systemType;117 »       »       ISystemType·systemType;
118 »       »       if·(ShipStatus.Instance.Systems.TryGetValue(SystemTypes.Ventilation,·out·systemType))118 »       »       if·(ShipStatus.Instance.Systems.TryGetValue(SystemTypes.Ventilation,·out·systemType))
119 »       »       {119 »       »       {
2.29 KB
Assembly-CSharp/VentilationSystem.cs
    
Offset 30, 15 lines modifiedOffset 30, 15 lines modified
30 »       public·void·Deteriorate(float·deltaTime)30 »       public·void·Deteriorate(float·deltaTime)
31 »       {31 »       {
32 »       »       if·(GameData.Instance)32 »       »       if·(GameData.Instance)
33 »       »       {33 »       »       {
34 »       »       »       foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersCleaningVents)34 »       »       »       foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersCleaningVents)
35 »       »       »       {35 »       »       »       {
36 »       »       »       »       byte·key·=·keyValuePair.Key;36 »       »       »       »       byte·key·=·keyValuePair.Key;
37 »       »       »       »       GameData.PlayerInfo·playerById·=·GameData.Instance.GetPlayerById(key);37 »       »       »       »       NetworkedPlayerInfo·playerById·=·GameData.Instance.GetPlayerById(key);
38 »       »       »       »       if·(playerById·==·null·||·playerById.Disconnected)38 »       »       »       »       if·(playerById·==·null·||·playerById.Disconnected)
39 »       »       »       »       {39 »       »       »       »       {
40 »       »       »       »       »       this.ToRemove.Add(key);40 »       »       »       »       »       this.ToRemove.Add(key);
41 »       »       »       »       }41 »       »       »       »       }
42 »       »       »       }42 »       »       »       }
43 »       »       »       if·(this.ToRemove.Count·>·0)43 »       »       »       if·(this.ToRemove.Count·>·0)
44 »       »       »       {44 »       »       »       {
Offset 66, 15 lines modifiedOffset 66, 15 lines modified
66 »       »       return·false;66 »       »       return·false;
67 »       }67 »       }
68 68
69 »       public·bool·IsImpostorInsideVent(int·ventId)69 »       public·bool·IsImpostorInsideVent(int·ventId)
70 »       {70 »       {
71 »       »       foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersInsideVents)71 »       »       foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·this.PlayersInsideVents)
72 »       »       {72 »       »       {
73 »       »       »       if·((int)keyValuePair.Value·==·ventId)73 »       »       »       if·((int)keyValuePair.Value·==·ventId·&&·!this.IsInvisiblePhantomOnVent(keyValuePair.Key))
74 »       »       »       {74 »       »       »       {
75 »       »       »       »       return·true;75 »       »       »       »       return·true;
76 »       »       »       }76 »       »       »       }
77 »       »       }77 »       »       }
78 »       »       return·false;78 »       »       return·false;
79 »       }79 »       }
80 80
Offset 185, 25 lines modifiedOffset 185, 45 lines modified
185 »       private·void·BootImpostorsFromVent(int·ventId)185 »       private·void·BootImpostorsFromVent(int·ventId)
186 »       {186 »       {
187 »       »       foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·Enumerable.ToArray<KeyValuePair<byte,·byte>>(this.PlayersInsideVents))187 »       »       foreach·(KeyValuePair<byte,·byte>·keyValuePair·in·Enumerable.ToArray<KeyValuePair<byte,·byte>>(this.PlayersInsideVents))
188 »       »       {188 »       »       {
189 »       »       »       if·((int)keyValuePair.Value·==·ventId)189 »       »       »       if·((int)keyValuePair.Value·==·ventId)
190 »       »       »       {190 »       »       »       {
191 »       »       »       »       byte·key·=·keyValuePair.Key;191 »       »       »       »       byte·key·=·keyValuePair.Key;
 192 »       »       »       »       if·(!this.IsInvisiblePhantomOnVent(key))
 193 »       »       »       »       {
192 »       »       »       »       this.PlayersInsideVents.Remove(key);194 »       »       »       »       »       this.PlayersInsideVents.Remove(key);
193 »       »       »       »       this.BootImpostorFromVent(ventId,·key);195 »       »       »       »       »       this.BootImpostorFromVent(ventId,·key);
194 »       »       »       »       this.IsDirty·=·true;196 »       »       »       »       »       this.IsDirty·=·true;
 197 »       »       »       »       }
195 »       »       »       }198 »       »       »       }
196 »       »       }199 »       »       }
197 »       »       if·(this.IsDirty)200 »       »       if·(this.IsDirty)
198 »       »       {201 »       »       {
199 »       »       »       this.UpdateVentArrows();202 »       »       »       this.UpdateVentArrows();
200 »       »       }203 »       »       }
201 »       }204 »       }
202 205
 206 »       private·bool·IsInvisiblePhantomOnVent(byte·playerId)
 207 »       {
 208 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
 209 »       »       {
 210 »       »       »       if·(playerControl.PlayerId·==·playerId)
 211 »       »       »       {
 212 »       »       »       »       PhantomRole·phantomRole·=·playerControl.Data.Role·as·PhantomRole;
 213 »       »       »       »       if·(phantomRole·!=·null)
 214 »       »       »       »       {
 215 »       »       »       »       »       return·phantomRole.IsInvisible;
 216 »       »       »       »       }
 217 »       »       »       »       return·false;
 218 »       »       »       }
 219 »       »       }
 220 »       »       return·false;
 221 »       }
 222
203 »       private·void·BootImpostorFromVent(int·ventId,·byte·playerId)223 »       private·void·BootImpostorFromVent(int·ventId,·byte·playerId)
204 »       {224 »       {
205 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)225 »       »       foreach·(PlayerControl·playerControl·in·PlayerControl.AllPlayerControls)
206 »       »       {226 »       »       {
207 »       »       »       if·(playerControl.PlayerId·==·playerId)227 »       »       »       if·(playerControl.PlayerId·==·playerId)
208 »       »       »       {228 »       »       »       {
209 »       »       »       »       playerControl.MyPhysics.RpcBootFromVent(ventId);229 »       »       »       »       playerControl.MyPhysics.RpcBootFromVent(ventId);
676 B
Assembly-CSharp/VersionShower.cs
    
Offset 8, 18 lines modifiedOffset 8, 18 lines modified
8 »       {8 »       {
9 »       »       string·text·=·"v"·+·Application.version;9 »       »       string·text·=·"v"·+·Application.version;
10 »       »       text·+=·"s";10 »       »       text·+=·"s";
11 »       »       if·(!global::DetectTamper.Detect())11 »       »       if·(!global::DetectTamper.Detect())
12 »       »       {12 »       »       {
13 »       »       »       text·+=·"h";13 »       »       »       text·+=·"h";
14 »       »       }14 »       »       }
15 »       »       if·(!string.IsNullOrEmpty("(build·num:·4234)"))15 »       »       if·(!string.IsNullOrEmpty("(build·num:·4431)"))
16 »       »       {16 »       »       {
17 »       »       »       text·+=·"·(build·num:·4234)";17 »       »       »       text·+=·"·(build·num:·4431)";
18 »       »       }18 »       »       }
19 »       »       this.text.text·=·text;19 »       »       this.text.text·=·text;
20 »       »       Screen.sleepTimeout·=·-1;20 »       »       Screen.sleepTimeout·=·-1;
21 »       »       Debug.Log("Among·Us·Version·"·+·text·+·"·Pipeline·Build·Num:·"·+·4234.ToString());21 »       »       Debug.Log("Among·Us·Version·"·+·text·+·"·Pipeline·Build·Num:·"·+·4431.ToString());
22 »       }22 »       }
23 23
24 »       public·TextMeshPro·text;24 »       public·TextMeshPro·text;
25 }25 }
428 B
Assembly-CSharp/VertLineBehaviour.cs
Ordering differences only
    
Offset 1, 12 lines modifiedOffset 1, 12 lines modified
1 using·System;1 using·System;
2 using·UnityEngine;2 using·UnityEngine;
3 3
4 [RequireComponent(typeof(MeshRenderer))] 
5 [RequireComponent(typeof(MeshFilter))]4 [RequireComponent(typeof(MeshFilter))]
 5 [RequireComponent(typeof(MeshRenderer))]
6 public·class·VertLineBehaviour·:·MonoBehaviour6 public·class·VertLineBehaviour·:·MonoBehaviour
7 {7 {
8 »       public·Color·color8 »       public·Color·color
9 »       {9 »       {
10 »       »       set10 »       »       set
11 »       »       {11 »       »       {
12 »       »       »       this.rend.material.SetColor("_Color",·value);12 »       »       »       this.rend.material.SetColor("_Color",·value);
1.03 KB
Assembly-CSharp/VisorLayer.cs
    
Offset 133, 23 lines modifiedOffset 133, 42 lines modified
133 133
134 »       public·void·SetLocalPlayer(bool·localPlayer)134 »       public·void·SetLocalPlayer(bool·localPlayer)
135 »       {135 »       {
136 »       »       this.matProperties.IsLocalPlayer·=·localPlayer;136 »       »       this.matProperties.IsLocalPlayer·=·localPlayer;
137 »       »       this.UpdateMaterial();137 »       »       this.UpdateMaterial();
138 »       }138 »       }
139 139
 140 »       public·void·SetIdleAnim(int·colorId)
 141 »       {
 142 »       »       if·(!this.visorData)
 143 »       »       {
 144 »       »       »       return;
 145 »       »       }
 146 »       »       this.SetVisor(this.visorData,·colorId);
 147 »       }
 148
140 »       public·void·SetFloorAnim()149 »       public·void·SetFloorAnim()
141 »       {150 »       {
142 »       »       if·(!this.IsLoaded)151 »       »       if·(!this.IsLoaded)
143 »       »       {152 »       »       {
144 »       »       »       return;153 »       »       »       return;
145 »       »       }154 »       »       }
146 »       »       this.Image.sprite·=·this.viewAsset.GetAsset().FloorFrame;155 »       »       this.Image.sprite·=·this.viewAsset.GetAsset().FloorFrame;
147 »       }156 »       }
148 157
 158 »       public·void·SetClimbAnim(PlayerBodyTypes·bodyType)
 159 »       {
 160 »       »       if·(this.options.HideDuringClimb·||·bodyType·==·PlayerBodyTypes.Horse)
 161 »       »       {
 162 »       »       »       return;
 163 »       »       }
 164 »       »       base.transform.localPosition·=·new·Vector3(base.transform.localPosition.x,·base.transform.localPosition.y,·0f);
 165 »       »       this.Image.sprite·=·this.viewAsset.GetAsset().ClimbFrame;
 166 »       }
 167
149 »       public·void·SetMaskType(PlayerMaterial.MaskType·maskType)168 »       public·void·SetMaskType(PlayerMaterial.MaskType·maskType)
150 »       {169 »       {
151 »       »       this.matProperties.MaskType·=·maskType;170 »       »       this.matProperties.MaskType·=·maskType;
152 »       »       this.UpdateMaterial();171 »       »       this.UpdateMaterial();
153 »       }172 »       }
154 173
155 »       public·void·SetMaterialColor(int·color)174 »       public·void·SetMaterialColor(int·color)
2.29 KB
Assembly-CSharp/VitalsMinigame.cs
    
Offset 6, 52 lines modifiedOffset 6, 52 lines modified
6 6
7 public·class·VitalsMinigame·:·Minigame7 public·class·VitalsMinigame·:·Minigame
8 {8 {
9 »       public·override·void·Begin(PlayerTask·task)9 »       public·override·void·Begin(PlayerTask·task)
10 »       {10 »       {
11 »       »       base.Begin(task);11 »       »       base.Begin(task);
12 »       »       DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>();12 »       »       DeadBody[]·array·=·Object.FindObjectsOfType<DeadBody>();
13 »       »       List<GameData.PlayerInfo>·list·=·new·List<GameData.PlayerInfo>();13 »       »       List<NetworkedPlayerInfo>·list·=·new·List<NetworkedPlayerInfo>();
14 »       »       list.AddRange(GameData.Instance.AllPlayers);14 »       »       list.AddRange(GameData.Instance.AllPlayers);
15 »       »       Dictionary<byte,·bool>·vitalDisconnected·=·new·Dictionary<byte,·bool>();15 »       »       Dictionary<byte,·bool>·vitalDisconnected·=·new·Dictionary<byte,·bool>();
16 »       »       using·(List<GameData.PlayerInfo>.Enumerator·enumerator·=·list.GetEnumerator())16 »       »       using·(List<NetworkedPlayerInfo>.Enumerator·enumerator·=·list.GetEnumerator())
17 »       »       {17 »       »       {
18 »       »       »       while·(enumerator.MoveNext())18 »       »       »       while·(enumerator.MoveNext())
19 »       »       »       {19 »       »       »       {
20 »       »       »       »       GameData.PlayerInfo·player·=·enumerator.Current;20 »       »       »       »       NetworkedPlayerInfo·player·=·enumerator.Current;
21 »       »       »       »       bool·flag·=·!Enumerable.Any<DeadBody>(array,·(DeadBody·b)·=>·b.ParentId·==·player.PlayerId);21 »       »       »       »       bool·flag·=·!Enumerable.Any<DeadBody>(array,·(DeadBody·b)·=>·b.ParentId·==·player.PlayerId);
22 »       »       »       »       vitalDisconnected[player.PlayerId]·=·flag·&&·(player.Disconnected·||·player.IsDead);22 »       »       »       »       vitalDisconnected[player.PlayerId]·=·flag·&&·(player.Disconnected·||·player.IsDead);
23 »       »       »       }23 »       »       »       }
24 »       »       }24 »       »       }
25 »       »       list.Sort(delegate(GameData.PlayerInfo·a,·GameData.PlayerInfo·b)25 »       »       list.Sort(delegate(NetworkedPlayerInfo·a,·NetworkedPlayerInfo·b)
26 »       »       {26 »       »       {
27 »       »       »       if·(vitalDisconnected[a.PlayerId]·&&·!vitalDisconnected[b.PlayerId])27 »       »       »       if·(vitalDisconnected[a.PlayerId]·&&·!vitalDisconnected[b.PlayerId])
28 »       »       »       {28 »       »       »       {
29 »       »       »       »       return·1;29 »       »       »       »       return·1;
30 »       »       »       }30 »       »       »       }
31 »       »       »       if·(!vitalDisconnected[a.PlayerId]·&&·vitalDisconnected[b.PlayerId])31 »       »       »       if·(!vitalDisconnected[a.PlayerId]·&&·vitalDisconnected[b.PlayerId])
32 »       »       »       {32 »       »       »       {
33 »       »       »       »       return·-1;33 »       »       »       »       return·-1;
34 »       »       »       }34 »       »       »       }
35 »       »       »       return·0;35 »       »       »       return·0;
36 »       »       });36 »       »       });
37 »       »       this.vitals·=·new·VitalsPanel[list.Count];37 »       »       this.vitals·=·new·VitalsPanel[list.Count];
38 »       »       for·(int·i·=·0;·i·<·list.Count;·i++)38 »       »       for·(int·i·=·0;·i·<·list.Count;·i++)
39 »       »       {39 »       »       {
40 »       »       »       GameData.PlayerInfo·playerInfo·=·list[i];40 »       »       »       NetworkedPlayerInfo·networkedPlayerInfo·=·list[i];
41 »       »       »       int·num·=·i·%·3;41 »       »       »       int·num·=·i·%·3;
42 »       »       »       int·num2·=·i·/·3;42 »       »       »       int·num2·=·i·/·3;
43 »       »       »       VitalsPanel·vitalsPanel·=·Object.Instantiate<VitalsPanel>(this.PanelPrefab,·base.transform);43 »       »       »       VitalsPanel·vitalsPanel·=·Object.Instantiate<VitalsPanel>(this.PanelPrefab,·base.transform);
44 »       »       »       vitalsPanel.transform.localPosition·=·new·Vector3(this.XStart·+·(float)num·*·this.XOffset,·this.YStart·+·(float)num2·*·this.YOffset,·-1f);44 »       »       »       vitalsPanel.transform.localPosition·=·new·Vector3(this.XStart·+·(float)num·*·this.XOffset,·this.YStart·+·(float)num2·*·this.YOffset,·-1f);
45 »       »       »       vitalsPanel.SetPlayer(i,·playerInfo);45 »       »       »       vitalsPanel.SetPlayer(i,·networkedPlayerInfo);
46 »       »       »       if·(vitalDisconnected[playerInfo.PlayerId])46 »       »       »       if·(vitalDisconnected[networkedPlayerInfo.PlayerId])
47 »       »       »       {47 »       »       »       {
48 »       »       »       »       vitalsPanel.SetDisconnected();48 »       »       »       »       vitalsPanel.SetDisconnected();
49 »       »       »       }49 »       »       »       }
50 »       »       »       else·if·(playerInfo.IsDead)50 »       »       »       else·if·(networkedPlayerInfo.IsDead)
51 »       »       »       {51 »       »       »       {
52 »       »       »       »       vitalsPanel.SetDead();52 »       »       »       »       vitalsPanel.SetDead();
53 »       »       »       }53 »       »       »       }
54 »       »       »       else54 »       »       »       else
55 »       »       »       {55 »       »       »       {
56 »       »       »       »       vitalsPanel.SetAlive();56 »       »       »       »       vitalsPanel.SetAlive();
57 »       »       »       }57 »       »       »       }
856 B
Assembly-CSharp/VitalsPanel.cs
    
Offset 1, 17 lines modifiedOffset 1, 17 lines modified
1 using·System;1 using·System;
2 using·AmongUs.Data;2 using·AmongUs.Data;
3 using·TMPro;3 using·TMPro;
4 using·UnityEngine;4 using·UnityEngine;
5 5
6 public·class·VitalsPanel·:·MonoBehaviour6 public·class·VitalsPanel·:·MonoBehaviour
7 {7 {
8 »       public·GameData.PlayerInfo·PlayerInfo·{·get;·set;·}8 »       public·NetworkedPlayerInfo·PlayerInfo·{·get;·set;·}
9 9
10 »       public·void·SetPlayer(int·index,·GameData.PlayerInfo·playerInfo)10 »       public·void·SetPlayer(int·index,·NetworkedPlayerInfo·playerInfo)
11 »       {11 »       {
12 »       »       this.PlayerInfo·=·playerInfo;12 »       »       this.PlayerInfo·=·playerInfo;
13 »       »       this.PlayerIcon.SetFlipX(false);13 »       »       this.PlayerIcon.SetFlipX(false);
14 »       »       this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null);14 »       »       this.PlayerIcon.UpdateFromEitherPlayerDataOrCache(playerInfo,·PlayerOutfitType.Default,·PlayerMaterial.MaskType.ComplexUI,·false,·null);
15 »       »       this.PlayerIcon.ToggleName(false);15 »       »       this.PlayerIcon.ToggleName(false);
16 »       »       this.ColorBlindName.text·=·this.PlayerIcon.ColorBlindName;16 »       »       this.ColorBlindName.text·=·this.PlayerIcon.ColorBlindName;
17 »       »       this.ColorBlindName.enabled·=·DataManager.Settings.Accessibility.ColorBlindMode;17 »       »       this.ColorBlindName.enabled·=·DataManager.Settings.Accessibility.ColorBlindMode;
498 B
Assembly-CSharp/VoteBanSystem.cs
    
Offset 74, 15 lines modifiedOffset 74, 18 lines modified
74 »       »       {74 »       »       {
75 »       »       »       writer.Write(keyValuePair.Key);75 »       »       »       writer.Write(keyValuePair.Key);
76 »       »       »       for·(int·i·=·0;·i·<·3;·i++)76 »       »       »       for·(int·i·=·0;·i·<·3;·i++)
77 »       »       »       {77 »       »       »       {
78 »       »       »       »       writer.WritePacked(keyValuePair.Value[i]);78 »       »       »       »       writer.WritePacked(keyValuePair.Value[i]);
79 »       »       »       }79 »       »       »       }
80 »       »       }80 »       »       }
 81 »       »       if·(!initialState)
 82 »       »       {
81 »       »       base.ClearDirtyBits();83 »       »       »       base.ClearDirtyBits();
 84 »       »       }
82 »       »       return·true;85 »       »       return·true;
83 »       }86 »       }
84 87
85 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)88 »       public·override·void·Deserialize(MessageReader·reader,·bool·initialState)
86 »       {89 »       {
87 »       »       int·num·=·(int)reader.ReadByte();90 »       »       int·num·=·(int)reader.ReadByte();
88 »       »       for·(int·i·=·0;·i·<·num;·i++)91 »       »       for·(int·i·=·0;·i·<·num;·i++)
4.8 KB
Assembly-CSharp/ZiplineBehaviour.cs
    
Offset 140, 23 lines modifiedOffset 140, 23 lines modified
140 »       »       »       yield·return·null;140 »       »       »       yield·return·null;
141 »       »       }141 »       »       }
142 »       »       this.PreparePlayerForZipline(player,·true);142 »       »       this.PreparePlayerForZipline(player,·true);
143 »       »       yield·return·this.CoWalkPlayerToZipline(player,·start.position);143 »       »       yield·return·this.CoWalkPlayerToZipline(player,·start.position);
144 »       »       GameServerUtils.DebugTime("walkToSeconds",·ref·ziplineTime,·Time.time);144 »       »       GameServerUtils.DebugTime("walkToSeconds",·ref·ziplineTime,·Time.time);
145 »       »       HandZiplinePoolable·currentHand·=·this.GetHand();145 »       »       HandZiplinePoolable·currentHand·=·this.GetHand();
146 »       »       this.playerIdHands[player.PlayerId]·=·currentHand;146 »       »       this.playerIdHands[player.PlayerId]·=·currentHand;
147 »       »       currentHand.SetPlayerColor(player.CurrentOutfit,·PlayerMaterial.MaskType.None);147 »       »       currentHand.SetPlayerColor(player.CurrentOutfit,·PlayerMaterial.MaskType.None,·player.cosmetics.GetPhantomRoleAlpha());
148 »       »       this.PlaySound(this.attachSound,·start.position,·PlayerControl.LocalPlayer.GetTruePosition());148 »       »       this.PlaySound(this.attachSound,·start.position,·player);
149 »       »       yield·return·this.CoAnimatePlayerJumpingOnToZipline(player,·fromTop,·currentHand);149 »       »       yield·return·this.CoAnimatePlayerJumpingOnToZipline(player,·fromTop,·currentHand);
150 »       »       GameServerUtils.DebugTime("jumpToSeconds",·ref·ziplineTime,·Time.time);150 »       »       GameServerUtils.DebugTime("jumpToSeconds",·ref·ziplineTime,·Time.time);
151 »       »       this.StartSound(player,·fromTop);151 »       »       this.StartSound(player,·fromTop);
152 »       »       yield·return·this.CoAnimateZiplineAndPlayer(player,·end.position,·fromTop,·currentHand);152 »       »       yield·return·this.CoAnimateZiplineAndPlayer(player,·end.position,·fromTop,·currentHand);
153 »       »       GameServerUtils.DebugTime("travelSeconds",·ref·ziplineTime,·Time.time);153 »       »       GameServerUtils.DebugTime("travelSeconds",·ref·ziplineTime,·Time.time);
154 »       »       this.StopZiplineSound(player);154 »       »       this.StopZiplineSound(player);
155 »       »       this.PlaySound(this.detachSound,·end.position,·PlayerControl.LocalPlayer.GetTruePosition());155 »       »       this.PlaySound(this.detachSound,·end.position,·player);
156 »       »       yield·return·this.CoAlightPlayerFromZipline(player,·landing.position,·fromTop,·currentHand);156 »       »       yield·return·this.CoAlightPlayerFromZipline(player,·landing.position,·fromTop,·currentHand);
157 »       »       GameServerUtils.DebugTime("jumpFromSeconds·+·walkFrom·+·wait",·ref·ziplineTime,·Time.time);157 »       »       GameServerUtils.DebugTime("jumpFromSeconds·+·walkFrom·+·wait",·ref·ziplineTime,·Time.time);
158 »       »       GameServerUtils.DebugTime("totalZiplineSeconds·(compare·this·with·server·log·output)",·ref·totalTime,·Time.time);158 »       »       GameServerUtils.DebugTime("totalZiplineSeconds·(compare·this·with·server·log·output)",·ref·totalTime,·Time.time);
159 »       »       if·(this.lastUsedConsole·&&·player.AmOwner)159 »       »       if·(this.lastUsedConsole·&&·player.AmOwner)
160 »       »       {160 »       »       {
161 »       »       »       this.lastUsedConsole.SetDestinationCooldown();161 »       »       »       this.lastUsedConsole.SetDestinationCooldown();
162 »       »       }162 »       »       }
Offset 165, 14 lines modifiedOffset 165, 18 lines modified
165 »       »       this.ResetZipline();165 »       »       this.ResetZipline();
166 »       »       yield·break;166 »       »       yield·break;
167 »       }167 »       }
168 168
169 »       private·IEnumerator·CoAnimatePlayerJumpingOnToZipline(PlayerControl·player,·bool·fromTop,·HandZiplinePoolable·hand)169 »       private·IEnumerator·CoAnimatePlayerJumpingOnToZipline(PlayerControl·player,·bool·fromTop,·HandZiplinePoolable·hand)
170 »       {170 »       {
171 »       »       hand.gameObject.SetActive(true);171 »       »       hand.gameObject.SetActive(true);
 172 »       »       if·(!player.Visible)
 173 »       »       {
 174 »       »       »       hand.Hide();
 175 »       »       }
172 »       »       AnimationCurve·animationCurve;176 »       »       AnimationCurve·animationCurve;
173 »       »       if·(fromTop)177 »       »       if·(fromTop)
174 »       »       {178 »       »       {
175 »       »       »       hand.StartDownAnimation();179 »       »       »       hand.StartDownAnimation();
176 »       »       »       hand.transform.position·=·this.upHandPosition.position;180 »       »       »       hand.transform.position·=·this.upHandPosition.position;
177 »       »       »       animationCurve·=·this.jumpZiplineCurve;181 »       »       »       animationCurve·=·this.jumpZiplineCurve;
178 »       »       }182 »       »       }
Offset 306, 14 lines modifiedOffset 310, 18 lines modified
306 »       »       base.StartCoroutine(this.CoTogglePetVisibility(player,·0f,·true));310 »       »       base.StartCoroutine(this.CoTogglePetVisibility(player,·0f,·true));
307 »       »       yield·return·Effects.Wait(0.1f);311 »       »       yield·return·Effects.Wait(0.1f);
308 »       »       yield·break;312 »       »       yield·break;
309 »       }313 »       }
310 314
311 »       private·void·StartSound(PlayerControl·player,·bool·fromTop)315 »       private·void·StartSound(PlayerControl·player,·bool·fromTop)
312 »       {316 »       {
 317 »       »       if·(!player.Visible)
 318 »       »       {
 319 »       »       »       return;
 320 »       »       }
313 »       »       this.StopZiplineSound(player);321 »       »       this.StopZiplineSound(player);
314 »       »       if·(fromTop)322 »       »       if·(fromTop)
315 »       »       {323 »       »       {
316 »       »       »       this.soundLoopCoroutines[player.PlayerId]·=·this.CoDownSound(player);324 »       »       »       this.soundLoopCoroutines[player.PlayerId]·=·this.CoDownSound(player);
317 »       »       »       base.StartCoroutine(this.soundLoopCoroutines[player.PlayerId]);325 »       »       »       base.StartCoroutine(this.soundLoopCoroutines[player.PlayerId]);
318 »       »       »       return;326 »       »       »       return;
319 »       »       }327 »       »       }
Offset 363, 33 lines modifiedOffset 371, 33 lines modified
363 »       »       »       source.volume·=·0f;371 »       »       »       source.volume·=·0f;
364 »       »       »       return;372 »       »       »       return;
365 »       »       }373 »       »       }
366 »       »       source.volume·=·1f;374 »       »       source.volume·=·1f;
367 »       »       Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition();375 »       »       Vector2·truePosition·=·PlayerControl.LocalPlayer.GetTruePosition();
368 »       »       Vector2·closestPointOnLine·=·this.GetClosestPointOnLine(this.handleBottom.position,·this.handleTop.position,·truePosition);376 »       »       Vector2·closestPointOnLine·=·this.GetClosestPointOnLine(this.handleBottom.position,·this.handleTop.position,·truePosition);
369 »       »       float·num·=·Vector2.Distance(truePosition,·closestPointOnLine);377 »       »       float·num·=·Vector2.Distance(truePosition,·closestPointOnLine);
370 »       »       source.volume·=·SoundManager.GetSoundVolume(closestPointOnLine,·truePosition,·2f,·6f);378 »       »       source.volume·=·SoundManager.GetSoundVolume(closestPointOnLine,·truePosition,·2f,·6f,·0f);
371 »       »       if·(num·<·0.25f)379 »       »       if·(num·<·0.25f)
372 »       »       {380 »       »       {
373 »       »       »       VibrationManager.Vibrate(0.15f,·0.15f);381 »       »       »       VibrationManager.Vibrate(0.15f,·0.15f);
374 »       »       }382 »       »       }
375 »       }383 »       }
376 384
377 »       private·bool·ShouldPlaySound()385 »       private·bool·ShouldPlaySound()
378 »       {386 »       {
379 »       »       return·Constants.ShouldPlaySfx();387 »       »       return·Constants.ShouldPlaySfx();
380 »       }388 »       }
381 389
382 »       private·void·PlaySound(AudioClip·sound,·Vector2·soundPosition,·Vector2·playerPosition)390 »       private·void·PlaySound(AudioClip·sound,·Vector2·soundPosition,·PlayerControl·player)
383 »       {391 »       {
384 »       »       if·(!this.ShouldPlaySound())392 »       »       if·(!this.ShouldPlaySound()·||·!player.Visible)
385 »       »       {393 »       »       {
386 »       »       »       return;394 »       »       »       return;
387 »       »       }395 »       »       }
388 »       »       float·soundVolume·=·SoundManager.GetSoundVolume(soundPosition,·playerPosition,·2f,·6f);396 »       »       float·soundVolume·=·SoundManager.GetSoundVolume(soundPosition,·PlayerControl.LocalPlayer.GetTruePosition(),·2f,·6f,·0f);
389 »       »       if·(soundVolume·<=·0f)397 »       »       if·(soundVolume·<=·0f)
390 »       »       {398 »       »       {
391 »       »       »       return;399 »       »       »       return;
392 »       »       }400 »       »       }
393 »       »       SoundManager.Instance.PlaySoundImmediate(sound,·false,·soundVolume,·1f,·null);401 »       »       SoundManager.Instance.PlaySoundImmediate(sound,·false,·soundVolume,·1f,·null);
394 »       }402 »       }
395 403
Offset 453, 16 lines modifiedOffset 461, 16 lines modified
453 461
454 »       private·const·float·PET_HIDE_SPEED·=·2f;462 »       private·const·float·PET_HIDE_SPEED·=·2f;
455 463
456 »       private·const·float·TOGGLE_PET_INVISIBLE_SECONDS·=·0.5f;464 »       private·const·float·TOGGLE_PET_INVISIBLE_SECONDS·=·0.5f;
457 465
458 »       private·const·float·TOGGLE_PET_VISIBLE_SECONDS·=·0f;466 »       private·const·float·TOGGLE_PET_VISIBLE_SECONDS·=·0f;
459 467
460 »       [SerializeField] 
461 »       [Header("Positions")]468 »       [Header("Positions")]
 469 »       [SerializeField]
462 »       private·Transform·handleTop;470 »       private·Transform·handleTop;
463 471
464 »       [SerializeField]472 »       [SerializeField]
465 »       private·Transform·handleBottom;473 »       private·Transform·handleBottom;
466 474
467 »       [SerializeField]475 »       [SerializeField]
468 »       private·Transform·landingPositionBottom;476 »       private·Transform·landingPositionBottom;
Offset 472, 16 lines modifiedOffset 480, 16 lines modified
472 480
473 »       [SerializeField]481 »       [SerializeField]
474 »       private·Transform·dropPositionBottom;482 »       private·Transform·dropPositionBottom;
475 483
476 »       [SerializeField]484 »       [SerializeField]
477 »       private·Transform·dropPositionTop;485 »       private·Transform·dropPositionTop;
478 486
479 »       [SerializeField] 
480 »       [Header("Travel·time")]487 »       [Header("Travel·time")]
 488 »       [SerializeField]
481 »       private·float·upTravelTime·=·2f;489 »       private·float·upTravelTime·=·2f;
482 490
483 »       [SerializeField]491 »       [SerializeField]
Max diff block lines reached; 57/4847 bytes (1.18%) of diff not shown.
1.08 KB
Assembly-CSharp/ZiplineConsole.cs
    
Offset 50, 19 lines modifiedOffset 50, 19 lines modified
50 »       public·void·SetOutline(bool·on,·bool·mainTarget)50 »       public·void·SetOutline(bool·on,·bool·mainTarget)
51 »       {51 »       {
52 »       »       this.image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));52 »       »       this.image.material.SetFloat("_Outline",·(float)(on·?·1·:·0));
53 »       »       this.image.material.SetColor("_OutlineColor",·Color.white);53 »       »       this.image.material.SetColor("_OutlineColor",·Color.white);
54 »       »       this.image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear);54 »       »       this.image.material.SetColor("_AddColor",·mainTarget·?·Color.white·:·Color.clear);
55 »       }55 »       }
56 56
57 »       public·float·CanUse(GameData.PlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)57 »       public·float·CanUse(NetworkedPlayerInfo·pc,·out·bool·canUse,·out·bool·couldUse)
58 »       {58 »       {
59 »       »       float·num·=·float.MaxValue;59 »       »       float·num·=·float.MaxValue;
60 »       »       PlayerControl·@object·=·pc.Object;60 »       »       PlayerControl·@object·=·pc.Object;
61 »       »       couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!@object.isKilling;61 »       »       couldUse·=·!pc.IsDead·&&·@object.CanMove·&&·!@object.isKilling·&&·pc.Role.CanUse(this);
62 »       »       canUse·=·couldUse;62 »       »       canUse·=·couldUse;
63 »       »       if·(canUse)63 »       »       if·(canUse)
64 »       »       {64 »       »       {
65 »       »       »       Vector2·truePosition·=·@object.GetTruePosition();65 »       »       »       Vector2·truePosition·=·@object.GetTruePosition();
66 »       »       »       Vector3·position·=·base.transform.position;66 »       »       »       Vector3·position·=·base.transform.position;
67 »       »       »       num·=·Vector2.Distance(truePosition,·position);67 »       »       »       num·=·Vector2.Distance(truePosition,·position);
68 »       »       »       canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false);68 »       »       »       canUse·&=·num·<=·this.UsableDistance·&&·!PhysicsHelpers.AnythingBetween(truePosition,·position,·Constants.ShipOnlyMask,·false);